        TRUNCATE TABLE "dbrdf_teachingAssistantOf_delta_new";

        INSERT INTO "dbrdf_NR11_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR11_delta_old" t0;
        INSERT INTO "dbrdf_NR11"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR11_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NR11_delta_old";
        INSERT INTO "dbrdf_NR11_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR11_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR11_delta_new";

        INSERT INTO "dbrdf_TeachingAssistant_old"(s) SELECT t0.s FROM "dbrdf_TeachingAssistant_delta_old" t0;
        INSERT INTO "dbrdf_TeachingAssistant0"(s) SELECT DISTINCT t0.s FROM "dbrdf_TeachingAssistant_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TeachingAssistant_delta_old";
        INSERT INTO "dbrdf_TeachingAssistant_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TeachingAssistant_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TeachingAssistant_delta_new";

        INSERT INTO "dbrdf_Course_old"(s) SELECT t0.s FROM "dbrdf_Course_delta_old" t0;
        INSERT INTO "dbrdf_Course0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Course_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Course_delta_old";
        INSERT INTO "dbrdf_Course_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Course_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Course_delta_new";

        INSERT INTO "dbrdf_NR19_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR19_delta_old" t0;
        INSERT INTO "dbrdf_NR19"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR19_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NR19_delta_old";
        INSERT INTO "dbrdf_NR19_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR19_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR19_delta_new";

        INSERT INTO "dbrdf_SportsLover_old"(s) SELECT t0.s FROM "dbrdf_SportsLover_delta_old" t0;
        INSERT INTO "dbrdf_SportsLover"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsLover_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SportsLover_delta_old";
        INSERT INTO "dbrdf_SportsLover_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsLover_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SportsLover_delta_new";

        INSERT INTO "dbrdf_NR16_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR16_delta_old" t0;
        INSERT INTO "dbrdf_NR16"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR16_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NR16_delta_old";
        INSERT INTO "dbrdf_NR16_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR16_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR16_delta_new";

        INSERT INTO "dbrdf_SportsFan_old"(s) SELECT t0.s FROM "dbrdf_SportsFan_delta_old" t0;
        INSERT INTO "dbrdf_SportsFan"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsFan_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SportsFan_delta_old";
        INSERT INTO "dbrdf_SportsFan_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsFan_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SportsFan_delta_new";

        INSERT INTO "dbrdf_Sports_old"(s) SELECT t0.s FROM "dbrdf_Sports_delta_old" t0;
        INSERT INTO "dbrdf_Sports"(s) SELECT DISTINCT t0.s FROM "dbrdf_Sports_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Sports_delta_old";
        INSERT INTO "dbrdf_Sports_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Sports_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Sports_delta_new";

        INSERT INTO "dbrdf_TennisFan_old"(s) SELECT t0.s FROM "dbrdf_TennisFan_delta_old" t0;
        INSERT INTO "dbrdf_TennisFan"(s) SELECT DISTINCT t0.s FROM "dbrdf_TennisFan_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TennisFan_delta_old";
        INSERT INTO "dbrdf_TennisFan_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TennisFan_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TennisFan_delta_new";

        INSERT INTO "dbrdf_TennisClass_old"(s) SELECT t0.s FROM "dbrdf_TennisClass_delta_old" t0;
        INSERT INTO "dbrdf_TennisClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_TennisClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TennisClass_delta_old";
        INSERT INTO "dbrdf_TennisClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TennisClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TennisClass_delta_new";

        INSERT INTO "dbrdf_NR0_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR0_delta_old" t0;
        INSERT INTO "dbrdf_NR0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR0_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NR0_delta_old";
        INSERT INTO "dbrdf_NR0_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR0_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR0_delta_new";

        INSERT INTO "dbrdf_sameAs_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sameAs_delta_old" t0;
        INSERT INTO "dbrdf_sameAs"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sameAs_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_sameAs_delta_old";
        INSERT INTO "dbrdf_sameAs_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sameAs_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sameAs_delta_new";

        INSERT INTO "dbrdf_PeopleWithHobby_old"(s) SELECT t0.s FROM "dbrdf_PeopleWithHobby_delta_old" t0;
        INSERT INTO "dbrdf_PeopleWithHobby"(s) SELECT DISTINCT t0.s FROM "dbrdf_PeopleWithHobby_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PeopleWithHobby_delta_old";
        INSERT INTO "dbrdf_PeopleWithHobby_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PeopleWithHobby_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PeopleWithHobby_delta_new";

        INSERT INTO "dbrdf_like_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_like_delta_old" t0;
        INSERT INTO "dbrdf_like"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_like_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_like_delta_old";
        INSERT INTO "dbrdf_like_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_like_delta_new" t0;
        TRUNCATE TABLE "dbrdf_like_delta_new";

        INSERT INTO "dbrdf_NR15_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR15_delta_old" t0;
        INSERT INTO "dbrdf_NR15"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR15_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NR15_delta_old";
        INSERT INTO "dbrdf_NR15_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR15_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR15_delta_new";

        INSERT INTO "dbrdf_SwimmingLover_old"(s) SELECT t0.s FROM "dbrdf_SwimmingLover_delta_old" t0;
        INSERT INTO "dbrdf_SwimmingLover"(s) SELECT DISTINCT t0.s FROM "dbrdf_SwimmingLover_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SwimmingLover_delta_old";
        INSERT INTO "dbrdf_SwimmingLover_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SwimmingLover_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SwimmingLover_delta_new";

        INSERT INTO "dbrdf_SwimmingClass_old"(s) SELECT t0.s FROM "dbrdf_SwimmingClass_delta_old" t0;
        INSERT INTO "dbrdf_SwimmingClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_SwimmingClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SwimmingClass_delta_old";
        INSERT INTO "dbrdf_SwimmingClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SwimmingClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SwimmingClass_delta_new";

        INSERT INTO "dbrdf_NR6_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR6_delta_old" t0;
        INSERT INTO "dbrdf_NR6"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR6_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NR6_delta_old";
        INSERT INTO "dbrdf_NR6_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR6_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR6_delta_new";

        INSERT INTO "dbrdf_SwimmingFan_old"(s) SELECT t0.s FROM "dbrdf_SwimmingFan_delta_old" t0;
        INSERT INTO "dbrdf_SwimmingFan"(s) SELECT DISTINCT t0.s FROM "dbrdf_SwimmingFan_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SwimmingFan_delta_old";
        INSERT INTO "dbrdf_SwimmingFan_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SwimmingFan_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SwimmingFan_delta_new";

        INSERT INTO "dbrdf_isCrazyAbout_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isCrazyAbout_delta_old" t0;
        INSERT INTO "dbrdf_isCrazyAbout"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isCrazyAbout_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_isCrazyAbout_delta_old";
        INSERT INTO "dbrdf_isCrazyAbout_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isCrazyAbout_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isCrazyAbout_delta_new";

        INSERT INTO "dbrdf_NR18_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR18_delta_old" t0;
        INSERT INTO "dbrdf_NR18"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR18_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NR18_delta_old";
        INSERT INTO "dbrdf_NR18_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR18_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR18_delta_new";

        INSERT INTO "dbrdf_BasketBallFan_old"(s) SELECT t0.s FROM "dbrdf_BasketBallFan_delta_old" t0;
        INSERT INTO "dbrdf_BasketBallFan"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketBallFan_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BasketBallFan_delta_old";
        INSERT INTO "dbrdf_BasketBallFan_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketBallFan_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BasketBallFan_delta_new";

        INSERT INTO "dbrdf_BasketBallClass_old"(s) SELECT t0.s FROM "dbrdf_BasketBallClass_delta_old" t0;
        INSERT INTO "dbrdf_BasketBallClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketBallClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BasketBallClass_delta_old";
        INSERT INTO "dbrdf_BasketBallClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketBallClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BasketBallClass_delta_new";

        INSERT INTO "dbrdf_NR21_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR21_delta_old" t0;
        INSERT INTO "dbrdf_NR21"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR21_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NR21_delta_old";
        INSERT INTO "dbrdf_NR21_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR21_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR21_delta_new";

        INSERT INTO "dbrdf_BasketBallLover_old"(s) SELECT t0.s FROM "dbrdf_BasketBallLover_delta_old" t0;
        INSERT INTO "dbrdf_BasketBallLover"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketBallLover_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BasketBallLover_delta_old";
        INSERT INTO "dbrdf_BasketBallLover_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketBallLover_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BasketBallLover_delta_new";

        INSERT INTO "dbrdf_NonScienceStudent_old"(s) SELECT t0.s FROM "dbrdf_NonScienceStudent_delta_old" t0;
        INSERT INTO "dbrdf_NonScienceStudent"(s) SELECT DISTINCT t0.s FROM "dbrdf_NonScienceStudent_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NonScienceStudent_delta_old";
        INSERT INTO "dbrdf_NonScienceStudent_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_NonScienceStudent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NonScienceStudent_delta_new";

        INSERT INTO "dbrdf_hasMajor_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasMajor_delta_old" t0;
        INSERT INTO "dbrdf_hasMajor"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasMajor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_hasMajor_delta_old";
        INSERT INTO "dbrdf_hasMajor_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasMajor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_hasMajor_delta_new";

        INSERT INTO "dbrdf_ScienceStudent_old"(s) SELECT t0.s FROM "dbrdf_ScienceStudent_delta_old" t0;
        INSERT INTO "dbrdf_ScienceStudent"(s) SELECT DISTINCT t0.s FROM "dbrdf_ScienceStudent_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ScienceStudent_delta_old";
        INSERT INTO "dbrdf_ScienceStudent_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ScienceStudent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ScienceStudent_delta_new";

        INSERT INTO "dbrdf_Science_old"(s) SELECT t0.s FROM "dbrdf_Science_delta_old" t0;
        INSERT INTO "dbrdf_Science"(s) SELECT DISTINCT t0.s FROM "dbrdf_Science_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Science_delta_old";
        INSERT INTO "dbrdf_Science_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Science_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Science_delta_new";

        INSERT INTO "dbrdf_NR20_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR20_delta_old" t0;
        INSERT INTO "dbrdf_NR20"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR20_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NR20_delta_old";
        INSERT INTO "dbrdf_NR20_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR20_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR20_delta_new";

        INSERT INTO "dbrdf_UndergraduateStudent_old"(s) SELECT t0.s FROM "dbrdf_UndergraduateStudent_delta_old" t0;
        INSERT INTO "dbrdf_UndergraduateStudent0"(s) SELECT DISTINCT t0.s FROM "dbrdf_UndergraduateStudent_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_UndergraduateStudent_delta_old";
        INSERT INTO "dbrdf_UndergraduateStudent_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_UndergraduateStudent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_UndergraduateStudent_delta_new";

        INSERT INTO "dbrdf_hasStudent_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasStudent_delta_old" t0;
        INSERT INTO "dbrdf_hasStudent"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasStudent_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_hasStudent_delta_old";
        INSERT INTO "dbrdf_hasStudent_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasStudent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_hasStudent_delta_new";

        INSERT INTO "dbrdf_isStudentOf_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isStudentOf_delta_old" t0;
        INSERT INTO "dbrdf_isStudentOf"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isStudentOf_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_isStudentOf_delta_old";
        INSERT INTO "dbrdf_isStudentOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isStudentOf_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isStudentOf_delta_new";

        INSERT INTO "dbrdf_NR17_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR17_delta_old" t0;
        INSERT INTO "dbrdf_NR17"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR17_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NR17_delta_old";
        INSERT INTO "dbrdf_NR17_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR17_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR17_delta_new";

        INSERT INTO "dbrdf_Student_old"(s) SELECT t0.s FROM "dbrdf_Student_delta_old" t0;
        INSERT INTO "dbrdf_Student"(s) SELECT DISTINCT t0.s FROM "dbrdf_Student_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Student_delta_old";
        INSERT INTO "dbrdf_Student_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Student_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Student_delta_new";

        INSERT INTO "dbrdf_Organization_old"(s) SELECT t0.s FROM "dbrdf_Organization_delta_old" t0;
        INSERT INTO "dbrdf_Organization"(s) SELECT DISTINCT t0.s FROM "dbrdf_Organization_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Organization_delta_old";
        INSERT INTO "dbrdf_Organization_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Organization_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Organization_delta_new";

        INSERT INTO "dbrdf_hasMember_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasMember_delta_old" t0;
        INSERT INTO "dbrdf_hasMember"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasMember_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_hasMember_delta_old";
        INSERT INTO "dbrdf_hasMember_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasMember_delta_new" t0;
        TRUNCATE TABLE "dbrdf_hasMember_delta_new";

        INSERT INTO "dbrdf_isMemberOf_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isMemberOf_delta_old" t0;
        INSERT INTO "dbrdf_isMemberOf"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isMemberOf_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_isMemberOf_delta_old";
        INSERT INTO "dbrdf_isMemberOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isMemberOf_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isMemberOf_delta_new";

        INSERT INTO "dbrdf_worksFor_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_worksFor_delta_old" t0;
        INSERT INTO "dbrdf_worksFor0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_worksFor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_worksFor_delta_old";
        INSERT INTO "dbrdf_worksFor_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_worksFor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_worksFor_delta_new";

        INSERT INTO "dbrdf_NR1_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR1_delta_old" t0;
        INSERT INTO "dbrdf_NR1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR1_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_NR1_delta_old";
        INSERT INTO "dbrdf_NR1_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR1_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR1_delta_new";

        INSERT INTO "dbrdf_Employee_old"(s) SELECT t0.s FROM "dbrdf_Employee_delta_old" t0;
        INSERT INTO "dbrdf_Employee"(s) SELECT DISTINCT t0.s FROM "dbrdf_Employee_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Employee_delta_old";
        INSERT INTO "dbrdf_Employee_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Employee_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Employee_delta_new";

        INSERT INTO "dbrdf_Person_old"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0;
        INSERT INTO "dbrdf_Person"(s) SELECT DISTINCT t0.s FROM "dbrdf_Person_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Person_delta_old";
        INSERT INTO "dbrdf_Person_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Person_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Person_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_publicationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_publicationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_publicationDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_publicationDate_delta_old" ON "dbrdf_publicationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_publicationDate_delta_old" ON "dbrdf_publicationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_publicationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#publicationDate$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#publicationDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_publicationDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_publicationDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_publicationDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#publicationDate$delta_new>(?X0,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#publicationDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_publicationDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_publicationDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_publicationDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_publicationDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_publicationDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_publicationDate_delta_old";
        INSERT INTO "dbrdf_publicationDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_publicationDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_publicationDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 2
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicsClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicsClass_delta_old"(s) SELECT t0.s FROM "dbrdf_MusicsClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicsClass_delta_old" ON "dbrdf_MusicsClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicsClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#MusicsClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#MusicsClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MusicsClass_delta_new"(s) SELECT t1.o FROM "dbrdf_MusicsClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MusicsClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MusicsClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicsClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MusicsClass_delta_old";
        INSERT INTO "dbrdf_MusicsClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicsClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MusicsClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 3
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Performing_ArtsClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Performing_ArtsClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Performing_ArtsClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Performing_ArtsClass_delta_old" ON "dbrdf_Performing_ArtsClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Performing_ArtsClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Performing_ArtsClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Performing_ArtsClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Performing_ArtsClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Performing_ArtsClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Performing_ArtsClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Performing_ArtsClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Performing_ArtsClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Performing_ArtsClass_delta_old";
        INSERT INTO "dbrdf_Performing_ArtsClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Performing_ArtsClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Performing_ArtsClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 4
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Media_Arts_And_ciencesClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Media_Arts_And_ciencesClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Media_Arts_And_ciencesClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Media_Arts_And_ciencesClass_delta_old" ON "dbrdf_Media_Arts_And_ciencesClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Media_Arts_And_ciencesClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Media_Arts_And_ciencesClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Media_Arts_And_ciencesClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Media_Arts_And_ciencesClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Media_Arts_And_ciencesClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Media_Arts_And_ciencesClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Media_Arts_And_ciencesClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Media_Arts_And_ciencesClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Media_Arts_And_ciencesClass_delta_old";
        INSERT INTO "dbrdf_Media_Arts_And_ciencesClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Media_Arts_And_ciencesClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Media_Arts_And_ciencesClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 5
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_EconomicsClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_EconomicsClass_delta_old"(s) SELECT t0.s FROM "dbrdf_EconomicsClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_EconomicsClass_delta_old" ON "dbrdf_EconomicsClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_EconomicsClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#EconomicsClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#EconomicsClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_EconomicsClass_delta_new"(s) SELECT t1.o FROM "dbrdf_EconomicsClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_EconomicsClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_EconomicsClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_EconomicsClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_EconomicsClass_delta_old";
        INSERT INTO "dbrdf_EconomicsClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_EconomicsClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_EconomicsClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 6
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Electrical_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Electrical_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Electrical_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Electrical_EngineeringClass_delta_old" ON "dbrdf_Electrical_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Electrical_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Electrical_EngineeringClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Electrical_EngineeringClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Electrical_EngineeringClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Electrical_EngineeringClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Electrical_EngineeringClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Electrical_EngineeringClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Electrical_EngineeringClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Electrical_EngineeringClass_delta_old";
        INSERT INTO "dbrdf_Electrical_EngineeringClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Electrical_EngineeringClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Electrical_EngineeringClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 7
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_DramaClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_DramaClass_delta_old"(s) SELECT t0.s FROM "dbrdf_DramaClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_DramaClass_delta_old" ON "dbrdf_DramaClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_DramaClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#DramaClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#DramaClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_DramaClass_delta_new"(s) SELECT t1.o FROM "dbrdf_DramaClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_DramaClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_DramaClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_DramaClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_DramaClass_delta_old";
        INSERT INTO "dbrdf_DramaClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_DramaClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_DramaClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 8
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Music_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Music_delta_old"(s) SELECT t0.s FROM "dbrdf_Music" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Music_delta_old" ON "dbrdf_Music_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Music_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Music$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Music$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Music_delta_new"(s) SELECT t1.o FROM "dbrdf_Music_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Music" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Music"(s) SELECT DISTINCT t0.s FROM "dbrdf_Music_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Music_delta_old";
        INSERT INTO "dbrdf_Music_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Music_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Music_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 9
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_HumanitiesClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_HumanitiesClass_delta_old"(s) SELECT t0.s FROM "dbrdf_HumanitiesClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_HumanitiesClass_delta_old" ON "dbrdf_HumanitiesClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_HumanitiesClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_HumanitiesClass_delta_new"(s) SELECT t1.o FROM "dbrdf_HumanitiesClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_HumanitiesClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_HumanitiesClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_HumanitiesClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_HumanitiesClass_delta_old";
        INSERT INTO "dbrdf_HumanitiesClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_HumanitiesClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_HumanitiesClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 10
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Petroleuml_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Petroleuml_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Petroleuml_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Petroleuml_EngineeringClass_delta_old" ON "dbrdf_Petroleuml_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Petroleuml_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Petroleuml_EngineeringClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Petroleuml_EngineeringClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Petroleuml_EngineeringClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Petroleuml_EngineeringClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Petroleuml_EngineeringClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Petroleuml_EngineeringClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Petroleuml_EngineeringClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Petroleuml_EngineeringClass_delta_old";
        INSERT INTO "dbrdf_Petroleuml_EngineeringClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Petroleuml_EngineeringClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Petroleuml_EngineeringClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 11
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Book_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Book_delta_old"(s) SELECT t0.s FROM "dbrdf_Book" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Book_delta_old" ON "dbrdf_Book_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Book_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Book$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Book$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Book_delta_new"(s) SELECT t1.o FROM "dbrdf_Book_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Book" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Book"(s) SELECT DISTINCT t0.s FROM "dbrdf_Book_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Book_delta_old";
        INSERT INTO "dbrdf_Book_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Book_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Book_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 12
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Mechanical_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Mechanical_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Mechanical_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Mechanical_EngineeringClass_delta_old" ON "dbrdf_Mechanical_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Mechanical_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Mechanical_EngineeringClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Mechanical_EngineeringClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Mechanical_EngineeringClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Mechanical_EngineeringClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Mechanical_EngineeringClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Mechanical_EngineeringClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mechanical_EngineeringClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Mechanical_EngineeringClass_delta_old";
        INSERT INTO "dbrdf_Mechanical_EngineeringClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mechanical_EngineeringClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Mechanical_EngineeringClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 13
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Materical_Science_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Materical_Science_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Materical_Science_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Materical_Science_EngineeringClass_delta_old" ON "dbrdf_Materical_Science_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Materical_Science_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Materical_Science_EngineeringClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Materical_Science_EngineeringClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Materical_Science_EngineeringClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Materical_Science_EngineeringClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Materical_Science_EngineeringClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Materical_Science_EngineeringClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Materical_Science_EngineeringClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Materical_Science_EngineeringClass_delta_old";
        INSERT INTO "dbrdf_Materical_Science_EngineeringClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Materical_Science_EngineeringClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Materical_Science_EngineeringClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 14
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Aeronautical_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Aeronautical_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Aeronautical_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Aeronautical_EngineeringClass_delta_old" ON "dbrdf_Aeronautical_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Aeronautical_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Aeronautical_EngineeringClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Aeronautical_EngineeringClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Aeronautical_EngineeringClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Aeronautical_EngineeringClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Aeronautical_EngineeringClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Aeronautical_EngineeringClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Aeronautical_EngineeringClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Aeronautical_EngineeringClass_delta_old";
        INSERT INTO "dbrdf_Aeronautical_EngineeringClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Aeronautical_EngineeringClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Aeronautical_EngineeringClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 15
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_HistoryClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_HistoryClass_delta_old"(s) SELECT t0.s FROM "dbrdf_HistoryClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_HistoryClass_delta_old" ON "dbrdf_HistoryClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_HistoryClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#HistoryClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#HistoryClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_HistoryClass_delta_new"(s) SELECT t1.o FROM "dbrdf_HistoryClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_HistoryClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_HistoryClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_HistoryClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_HistoryClass_delta_old";
        INSERT INTO "dbrdf_HistoryClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_HistoryClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_HistoryClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 16
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Civil_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Civil_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Civil_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Civil_EngineeringClass_delta_old" ON "dbrdf_Civil_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Civil_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Civil_EngineeringClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Civil_EngineeringClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Civil_EngineeringClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Civil_EngineeringClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Civil_EngineeringClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Civil_EngineeringClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Civil_EngineeringClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Civil_EngineeringClass_delta_old";
        INSERT INTO "dbrdf_Civil_EngineeringClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Civil_EngineeringClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Civil_EngineeringClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 17
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Biomedical_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Biomedical_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Biomedical_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Biomedical_EngineeringClass_delta_old" ON "dbrdf_Biomedical_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Biomedical_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Biomedical_EngineeringClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Biomedical_EngineeringClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Biomedical_EngineeringClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Biomedical_EngineeringClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Biomedical_EngineeringClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Biomedical_EngineeringClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Biomedical_EngineeringClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Biomedical_EngineeringClass_delta_old";
        INSERT INTO "dbrdf_Biomedical_EngineeringClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Biomedical_EngineeringClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Biomedical_EngineeringClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 18
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Theatre_and_DanceClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Theatre_and_DanceClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Theatre_and_DanceClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Theatre_and_DanceClass_delta_old" ON "dbrdf_Theatre_and_DanceClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Theatre_and_DanceClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Theatre_and_DanceClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Theatre_and_DanceClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Theatre_and_DanceClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Theatre_and_DanceClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Theatre_and_DanceClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Theatre_and_DanceClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Theatre_and_DanceClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Theatre_and_DanceClass_delta_old";
        INSERT INTO "dbrdf_Theatre_and_DanceClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Theatre_and_DanceClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Theatre_and_DanceClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 19
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Manual_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Manual_delta_old"(s) SELECT t0.s FROM "dbrdf_Manual" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Manual_delta_old" ON "dbrdf_Manual_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Manual_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Manual$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Manual$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Manual_delta_new"(s) SELECT t1.o FROM "dbrdf_Manual_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Manual" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Manual"(s) SELECT DISTINCT t0.s FROM "dbrdf_Manual_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Manual_delta_old";
        INSERT INTO "dbrdf_Manual_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Manual_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Manual_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 20
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_EnglishClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_EnglishClass_delta_old"(s) SELECT t0.s FROM "dbrdf_EnglishClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_EnglishClass_delta_old" ON "dbrdf_EnglishClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_EnglishClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#EnglishClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#EnglishClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_EnglishClass_delta_new"(s) SELECT t1.o FROM "dbrdf_EnglishClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_EnglishClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_EnglishClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_EnglishClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_EnglishClass_delta_old";
        INSERT INTO "dbrdf_EnglishClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_EnglishClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_EnglishClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 21
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ConferencePaper_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ConferencePaper_delta_old"(s) SELECT t0.s FROM "dbrdf_ConferencePaper" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ConferencePaper_delta_old" ON "dbrdf_ConferencePaper_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ConferencePaper_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ConferencePaper$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ConferencePaper$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ConferencePaper_delta_new"(s) SELECT t1.o FROM "dbrdf_ConferencePaper_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ConferencePaper" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ConferencePaper"(s) SELECT DISTINCT t0.s FROM "dbrdf_ConferencePaper_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ConferencePaper_delta_old";
        INSERT INTO "dbrdf_ConferencePaper_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ConferencePaper_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ConferencePaper_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 22
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ArchitectureClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ArchitectureClass_delta_old"(s) SELECT t0.s FROM "dbrdf_ArchitectureClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ArchitectureClass_delta_old" ON "dbrdf_ArchitectureClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ArchitectureClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ArchitectureClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ArchitectureClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ArchitectureClass_delta_new"(s) SELECT t1.o FROM "dbrdf_ArchitectureClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ArchitectureClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ArchitectureClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_ArchitectureClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ArchitectureClass_delta_old";
        INSERT INTO "dbrdf_ArchitectureClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ArchitectureClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ArchitectureClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 23
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Modern_ArtsClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Modern_ArtsClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Modern_ArtsClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Modern_ArtsClass_delta_old" ON "dbrdf_Modern_ArtsClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Modern_ArtsClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Modern_ArtsClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Modern_ArtsClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Modern_ArtsClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Modern_ArtsClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Modern_ArtsClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Modern_ArtsClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Modern_ArtsClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Modern_ArtsClass_delta_old";
        INSERT INTO "dbrdf_Modern_ArtsClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Modern_ArtsClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Modern_ArtsClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 24
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_UnofficialPublication_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_UnofficialPublication_delta_old"(s) SELECT t0.s FROM "dbrdf_UnofficialPublication" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_UnofficialPublication_delta_old" ON "dbrdf_UnofficialPublication_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_UnofficialPublication_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#UnofficialPublication$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#UnofficialPublication$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_UnofficialPublication_delta_new"(s) SELECT t1.o FROM "dbrdf_UnofficialPublication_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_UnofficialPublication" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_UnofficialPublication"(s) SELECT DISTINCT t0.s FROM "dbrdf_UnofficialPublication_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_UnofficialPublication_delta_old";
        INSERT INTO "dbrdf_UnofficialPublication_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_UnofficialPublication_delta_new" t0;
        TRUNCATE TABLE "dbrdf_UnofficialPublication_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 25
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_PhilosophyClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PhilosophyClass_delta_old"(s) SELECT t0.s FROM "dbrdf_PhilosophyClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PhilosophyClass_delta_old" ON "dbrdf_PhilosophyClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PhilosophyClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#PhilosophyClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#PhilosophyClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PhilosophyClass_delta_new"(s) SELECT t1.o FROM "dbrdf_PhilosophyClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PhilosophyClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PhilosophyClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_PhilosophyClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PhilosophyClass_delta_old";
        INSERT INTO "dbrdf_PhilosophyClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PhilosophyClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PhilosophyClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 26
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Computer_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Computer_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Computer_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Computer_EngineeringClass_delta_old" ON "dbrdf_Computer_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Computer_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Computer_EngineeringClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Computer_EngineeringClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Computer_EngineeringClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Computer_EngineeringClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Computer_EngineeringClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Computer_EngineeringClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Computer_EngineeringClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Computer_EngineeringClass_delta_old";
        INSERT INTO "dbrdf_Computer_EngineeringClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Computer_EngineeringClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Computer_EngineeringClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 27
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Modern_LanguagesClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Modern_LanguagesClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Modern_LanguagesClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Modern_LanguagesClass_delta_old" ON "dbrdf_Modern_LanguagesClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Modern_LanguagesClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Modern_LanguagesClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Modern_LanguagesClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Modern_LanguagesClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Modern_LanguagesClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Modern_LanguagesClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Modern_LanguagesClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Modern_LanguagesClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Modern_LanguagesClass_delta_old";
        INSERT INTO "dbrdf_Modern_LanguagesClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Modern_LanguagesClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Modern_LanguagesClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 28
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_TechnicalReport_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TechnicalReport_delta_old"(s) SELECT t0.s FROM "dbrdf_TechnicalReport" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TechnicalReport_delta_old" ON "dbrdf_TechnicalReport_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TechnicalReport_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#TechnicalReport$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#TechnicalReport$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_TechnicalReport_delta_new"(s) SELECT t1.o FROM "dbrdf_TechnicalReport_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_TechnicalReport" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_TechnicalReport"(s) SELECT DISTINCT t0.s FROM "dbrdf_TechnicalReport_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TechnicalReport_delta_old";
        INSERT INTO "dbrdf_TechnicalReport_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TechnicalReport_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TechnicalReport_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 29
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_publicationResearch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_publicationResearch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_publicationResearch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_publicationResearch_delta_old" ON "dbrdf_publicationResearch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_publicationResearch_delta_old" ON "dbrdf_publicationResearch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_publicationResearch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#publicationResearch$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#publicationResearch$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_publicationResearch_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_publicationResearch_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_publicationResearch" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#publicationResearch$delta_new>(?X0,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#publicationResearch$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_publicationResearch_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_publicationResearch_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_publicationResearch" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_publicationResearch"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_publicationResearch_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_publicationResearch_delta_old";
        INSERT INTO "dbrdf_publicationResearch_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_publicationResearch_delta_new" t0;
        TRUNCATE TABLE "dbrdf_publicationResearch_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 30
    ---- DEPENDS ON: 29, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Research>(?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#publicationResearch>(?X,?X1) .
    INSERT INTO "dbrdf_Research"(s) SELECT DISTINCT t0.o FROM "dbrdf_publicationResearch" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Research" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Research>(?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#researchProject>(?X,?X1) .
    INSERT INTO "dbrdf_Research"(s) SELECT DISTINCT t0.o FROM "dbrdf_researchProject" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Research" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Research_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Research_delta_old"(s) SELECT t0.s FROM "dbrdf_Research" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Research_delta_old" ON "dbrdf_Research_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Research_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Research$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Research$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Research_delta_new"(s) SELECT t1.o FROM "dbrdf_Research_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Research" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Research"(s) SELECT DISTINCT t0.s FROM "dbrdf_Research_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Research_delta_old";
        INSERT INTO "dbrdf_Research_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Research_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Research_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 31
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AnthropologyClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AnthropologyClass_delta_old"(s) SELECT t0.s FROM "dbrdf_AnthropologyClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AnthropologyClass_delta_old" ON "dbrdf_AnthropologyClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AnthropologyClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#AnthropologyClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#AnthropologyClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_AnthropologyClass_delta_new"(s) SELECT t1.o FROM "dbrdf_AnthropologyClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_AnthropologyClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AnthropologyClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_AnthropologyClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AnthropologyClass_delta_old";
        INSERT INTO "dbrdf_AnthropologyClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AnthropologyClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AnthropologyClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 32
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_PsychologyClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PsychologyClass_delta_old"(s) SELECT t0.s FROM "dbrdf_PsychologyClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PsychologyClass_delta_old" ON "dbrdf_PsychologyClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PsychologyClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#PsychologyClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#PsychologyClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PsychologyClass_delta_new"(s) SELECT t1.o FROM "dbrdf_PsychologyClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PsychologyClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PsychologyClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_PsychologyClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PsychologyClass_delta_old";
        INSERT INTO "dbrdf_PsychologyClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PsychologyClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PsychologyClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 33
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Latin_ArtsClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Latin_ArtsClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Latin_ArtsClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Latin_ArtsClass_delta_old" ON "dbrdf_Latin_ArtsClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Latin_ArtsClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Latin_ArtsClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Latin_ArtsClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Latin_ArtsClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Latin_ArtsClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Latin_ArtsClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Latin_ArtsClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Latin_ArtsClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Latin_ArtsClass_delta_old";
        INSERT INTO "dbrdf_Latin_ArtsClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Latin_ArtsClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Latin_ArtsClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 34
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Asian_ArtsClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Asian_ArtsClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Asian_ArtsClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Asian_ArtsClass_delta_old" ON "dbrdf_Asian_ArtsClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Asian_ArtsClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Asian_ArtsClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Asian_ArtsClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Asian_ArtsClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Asian_ArtsClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Asian_ArtsClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Asian_ArtsClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Asian_ArtsClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Asian_ArtsClass_delta_old";
        INSERT INTO "dbrdf_Asian_ArtsClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Asian_ArtsClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Asian_ArtsClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 35
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Industry_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Industry_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Industry_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Industry_EngineeringClass_delta_old" ON "dbrdf_Industry_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Industry_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Industry_EngineeringClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Industry_EngineeringClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Industry_EngineeringClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Industry_EngineeringClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Industry_EngineeringClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Industry_EngineeringClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Industry_EngineeringClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Industry_EngineeringClass_delta_old";
        INSERT INTO "dbrdf_Industry_EngineeringClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Industry_EngineeringClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Industry_EngineeringClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 36
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_softwareDocumentation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_softwareDocumentation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_softwareDocumentation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_softwareDocumentation_delta_old" ON "dbrdf_softwareDocumentation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_softwareDocumentation_delta_old" ON "dbrdf_softwareDocumentation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_softwareDocumentation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#softwareDocumentation$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#softwareDocumentation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_softwareDocumentation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_softwareDocumentation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_softwareDocumentation" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#softwareDocumentation$delta_new>(?X0,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#softwareDocumentation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_softwareDocumentation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_softwareDocumentation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_softwareDocumentation" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_softwareDocumentation"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_softwareDocumentation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_softwareDocumentation_delta_old";
        INSERT INTO "dbrdf_softwareDocumentation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_softwareDocumentation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_softwareDocumentation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 37
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_softwareVersion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_softwareVersion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_softwareVersion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_softwareVersion_delta_old" ON "dbrdf_softwareVersion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_softwareVersion_delta_old" ON "dbrdf_softwareVersion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_softwareVersion_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#softwareVersion$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#softwareVersion$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_softwareVersion_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_softwareVersion_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_softwareVersion" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#softwareVersion$delta_new>(?X0,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#softwareVersion$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_softwareVersion_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_softwareVersion_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_softwareVersion" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_softwareVersion"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_softwareVersion_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_softwareVersion_delta_old";
        INSERT INTO "dbrdf_softwareVersion_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_softwareVersion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_softwareVersion_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 38
    ---- DEPENDS ON: 37, 36, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Software>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#softwareVersion>(?X,?X1) .
    INSERT INTO "dbrdf_Software"(s) SELECT DISTINCT t0.s FROM "dbrdf_softwareVersion" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Software" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Software>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#softwareDocumentation>(?X,?X1) .
    INSERT INTO "dbrdf_Software"(s) SELECT DISTINCT t0.s FROM "dbrdf_softwareDocumentation" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Software" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Software_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Software_delta_old"(s) SELECT t0.s FROM "dbrdf_Software" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Software_delta_old" ON "dbrdf_Software_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Software_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Software$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Software$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Software_delta_new"(s) SELECT t1.o FROM "dbrdf_Software_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Software" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Software"(s) SELECT DISTINCT t0.s FROM "dbrdf_Software_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Software_delta_old";
        INSERT INTO "dbrdf_Software_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Software_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Software_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 39
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ReligionsClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ReligionsClass_delta_old"(s) SELECT t0.s FROM "dbrdf_ReligionsClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ReligionsClass_delta_old" ON "dbrdf_ReligionsClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ReligionsClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ReligionsClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ReligionsClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ReligionsClass_delta_new"(s) SELECT t1.o FROM "dbrdf_ReligionsClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ReligionsClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ReligionsClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_ReligionsClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ReligionsClass_delta_old";
        INSERT INTO "dbrdf_ReligionsClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ReligionsClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ReligionsClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 40
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_JournalArticle_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_JournalArticle_delta_old"(s) SELECT t0.s FROM "dbrdf_JournalArticle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_JournalArticle_delta_old" ON "dbrdf_JournalArticle_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_JournalArticle_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#JournalArticle$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#JournalArticle$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_JournalArticle_delta_new"(s) SELECT t1.o FROM "dbrdf_JournalArticle_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_JournalArticle" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_JournalArticle"(s) SELECT DISTINCT t0.s FROM "dbrdf_JournalArticle_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_JournalArticle_delta_old";
        INSERT INTO "dbrdf_JournalArticle_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_JournalArticle_delta_new" t0;
        TRUNCATE TABLE "dbrdf_JournalArticle_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 41
    ---- DEPENDS ON: 40, 28, 21, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Article>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#JournalArticle>(?X) .
    INSERT INTO "dbrdf_Article"(s) SELECT t0.s FROM "dbrdf_JournalArticle" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Article" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Article>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#TechnicalReport>(?X) .
    INSERT INTO "dbrdf_Article"(s) SELECT t0.s FROM "dbrdf_TechnicalReport" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Article" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Article>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ConferencePaper>(?X) .
    INSERT INTO "dbrdf_Article"(s) SELECT t0.s FROM "dbrdf_ConferencePaper" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Article" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Article_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Article_delta_old"(s) SELECT t0.s FROM "dbrdf_Article" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Article_delta_old" ON "dbrdf_Article_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Article_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Article$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Article$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Article_delta_new"(s) SELECT t1.o FROM "dbrdf_Article_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Article" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Article"(s) SELECT DISTINCT t0.s FROM "dbrdf_Article_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Article_delta_old";
        INSERT INTO "dbrdf_Article_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Article_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Article_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 42
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_LinguisticsClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_LinguisticsClass_delta_old"(s) SELECT t0.s FROM "dbrdf_LinguisticsClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_LinguisticsClass_delta_old" ON "dbrdf_LinguisticsClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_LinguisticsClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#LinguisticsClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#LinguisticsClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_LinguisticsClass_delta_new"(s) SELECT t1.o FROM "dbrdf_LinguisticsClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_LinguisticsClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_LinguisticsClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_LinguisticsClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_LinguisticsClass_delta_old";
        INSERT INTO "dbrdf_LinguisticsClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_LinguisticsClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_LinguisticsClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 43
    ---- DEPENDS ON: 42, 39, 32, 31, 27, 25, 20, 15, 9, 5, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesAndSocial>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#LinguisticsClass>(?X) .
    INSERT INTO "dbrdf_HumanitiesAndSocial"(s) SELECT t0.s FROM "dbrdf_LinguisticsClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_HumanitiesAndSocial" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesAndSocial>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ReligionsClass>(?X) .
    INSERT INTO "dbrdf_HumanitiesAndSocial"(s) SELECT t0.s FROM "dbrdf_ReligionsClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_HumanitiesAndSocial" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesAndSocial>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#PsychologyClass>(?X) .
    INSERT INTO "dbrdf_HumanitiesAndSocial"(s) SELECT t0.s FROM "dbrdf_PsychologyClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_HumanitiesAndSocial" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesAndSocial>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#AnthropologyClass>(?X) .
    INSERT INTO "dbrdf_HumanitiesAndSocial"(s) SELECT t0.s FROM "dbrdf_AnthropologyClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_HumanitiesAndSocial" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesAndSocial>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Modern_LanguagesClass>(?X) .
    INSERT INTO "dbrdf_HumanitiesAndSocial"(s) SELECT t0.s FROM "dbrdf_Modern_LanguagesClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_HumanitiesAndSocial" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesAndSocial>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#PhilosophyClass>(?X) .
    INSERT INTO "dbrdf_HumanitiesAndSocial"(s) SELECT t0.s FROM "dbrdf_PhilosophyClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_HumanitiesAndSocial" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesAndSocial>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#EnglishClass>(?X) .
    INSERT INTO "dbrdf_HumanitiesAndSocial"(s) SELECT t0.s FROM "dbrdf_EnglishClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_HumanitiesAndSocial" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesAndSocial>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#HistoryClass>(?X) .
    INSERT INTO "dbrdf_HumanitiesAndSocial"(s) SELECT t0.s FROM "dbrdf_HistoryClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_HumanitiesAndSocial" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesAndSocial>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesClass>(?X) .
    INSERT INTO "dbrdf_HumanitiesAndSocial"(s) SELECT t0.s FROM "dbrdf_HumanitiesClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_HumanitiesAndSocial" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesAndSocial>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#EconomicsClass>(?X) .
    INSERT INTO "dbrdf_HumanitiesAndSocial"(s) SELECT t0.s FROM "dbrdf_EconomicsClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_HumanitiesAndSocial" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_HumanitiesAndSocial_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_HumanitiesAndSocial_delta_old"(s) SELECT t0.s FROM "dbrdf_HumanitiesAndSocial" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_HumanitiesAndSocial_delta_old" ON "dbrdf_HumanitiesAndSocial_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_HumanitiesAndSocial_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesAndSocial$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesAndSocial$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_HumanitiesAndSocial_delta_new"(s) SELECT t1.o FROM "dbrdf_HumanitiesAndSocial_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_HumanitiesAndSocial" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_HumanitiesAndSocial"(s) SELECT DISTINCT t0.s FROM "dbrdf_HumanitiesAndSocial_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_HumanitiesAndSocial_delta_old";
        INSERT INTO "dbrdf_HumanitiesAndSocial_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_HumanitiesAndSocial_delta_new" t0;
        TRUNCATE TABLE "dbrdf_HumanitiesAndSocial_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 44
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_notInValueSpace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_notInValueSpace_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_notInValueSpace" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_notInValueSpace_delta_old" ON "dbrdf_notInValueSpace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_notInValueSpace_delta_old" ON "dbrdf_notInValueSpace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_notInValueSpace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://www.w3.org/2003/11/swrlb#notInValueSpace$delta_new>(?Y,?X1) :- <http://www.w3.org/2003/11/swrlb#notInValueSpace$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_notInValueSpace_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_notInValueSpace_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_notInValueSpace" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://www.w3.org/2003/11/swrlb#notInValueSpace$delta_new>(?X0,?Y) :- <http://www.w3.org/2003/11/swrlb#notInValueSpace$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_notInValueSpace_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_notInValueSpace_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_notInValueSpace" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_notInValueSpace"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_notInValueSpace_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_notInValueSpace_delta_old";
        INSERT INTO "dbrdf_notInValueSpace_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_notInValueSpace_delta_new" t0;
        TRUNCATE TABLE "dbrdf_notInValueSpace_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 45
    ---- DEPENDS ON: 44, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] owl:Nothing(<int$false>) :- swrlb:notInValueSpace(?X1,xsd:string), <http://semantics.crl.ibm.com/univ-bench-dl.owl#firstName>(?X,?X1) .
    INSERT INTO "dbrdf_Nothing"(s) SELECT DISTINCT 26451 FROM "dbrdf_notInValueSpace" t0, "dbrdf_firstName" t1 WHERE t0.s = t1.o AND t0.o = 26452 AND NOT EXISTS (SELECT 1 FROM "dbrdf_Nothing" ex WHERE ex.s = 26451);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] owl:Nothing(<int$false>) :- swrlb:notInValueSpace(?X1,xsd:string), <http://semantics.crl.ibm.com/univ-bench-dl.owl#lastName>(?X,?X1) .
    INSERT INTO "dbrdf_Nothing"(s) SELECT DISTINCT 26451 FROM "dbrdf_notInValueSpace" t0, "dbrdf_lastName" t1 WHERE t0.s = t1.o AND t0.o = 26452 AND NOT EXISTS (SELECT 1 FROM "dbrdf_Nothing" ex WHERE ex.s = 26451);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Nothing_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Nothing_delta_old"(s) SELECT t0.s FROM "dbrdf_Nothing" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Nothing_delta_old" ON "dbrdf_Nothing_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Nothing_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://www.w3.org/2002/07/owl#Nothing$delta_new>(?Y) :- <http://www.w3.org/2002/07/owl#Nothing$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Nothing_delta_new"(s) SELECT t1.o FROM "dbrdf_Nothing_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Nothing" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Nothing"(s) SELECT DISTINCT t0.s FROM "dbrdf_Nothing_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Nothing_delta_old";
        INSERT INTO "dbrdf_Nothing_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Nothing_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Nothing_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 46
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Medieval_ArtsClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Medieval_ArtsClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Medieval_ArtsClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Medieval_ArtsClass_delta_old" ON "dbrdf_Medieval_ArtsClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Medieval_ArtsClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Medieval_ArtsClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Medieval_ArtsClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Medieval_ArtsClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Medieval_ArtsClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Medieval_ArtsClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Medieval_ArtsClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Medieval_ArtsClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Medieval_ArtsClass_delta_old";
        INSERT INTO "dbrdf_Medieval_ArtsClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Medieval_ArtsClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Medieval_ArtsClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 47
    ---- DEPENDS ON: 46, 34, 33, 23, 22, 18, 7, 4, 3, 2, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#FineArts>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Medieval_ArtsClass>(?X) .
    INSERT INTO "dbrdf_FineArts"(s) SELECT t0.s FROM "dbrdf_Medieval_ArtsClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FineArts" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#FineArts>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Asian_ArtsClass>(?X) .
    INSERT INTO "dbrdf_FineArts"(s) SELECT t0.s FROM "dbrdf_Asian_ArtsClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FineArts" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#FineArts>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Latin_ArtsClass>(?X) .
    INSERT INTO "dbrdf_FineArts"(s) SELECT t0.s FROM "dbrdf_Latin_ArtsClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FineArts" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#FineArts>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Modern_ArtsClass>(?X) .
    INSERT INTO "dbrdf_FineArts"(s) SELECT t0.s FROM "dbrdf_Modern_ArtsClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FineArts" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#FineArts>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ArchitectureClass>(?X) .
    INSERT INTO "dbrdf_FineArts"(s) SELECT t0.s FROM "dbrdf_ArchitectureClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FineArts" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#FineArts>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Theatre_and_DanceClass>(?X) .
    INSERT INTO "dbrdf_FineArts"(s) SELECT t0.s FROM "dbrdf_Theatre_and_DanceClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FineArts" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#FineArts>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#DramaClass>(?X) .
    INSERT INTO "dbrdf_FineArts"(s) SELECT t0.s FROM "dbrdf_DramaClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FineArts" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#FineArts>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Media_Arts_And_ciencesClass>(?X) .
    INSERT INTO "dbrdf_FineArts"(s) SELECT t0.s FROM "dbrdf_Media_Arts_And_ciencesClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FineArts" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#FineArts>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Performing_ArtsClass>(?X) .
    INSERT INTO "dbrdf_FineArts"(s) SELECT t0.s FROM "dbrdf_Performing_ArtsClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FineArts" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#FineArts>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#MusicsClass>(?X) .
    INSERT INTO "dbrdf_FineArts"(s) SELECT t0.s FROM "dbrdf_MusicsClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FineArts" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_FineArts_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FineArts_delta_old"(s) SELECT t0.s FROM "dbrdf_FineArts" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FineArts_delta_old" ON "dbrdf_FineArts_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FineArts_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#FineArts$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#FineArts$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FineArts_delta_new"(s) SELECT t1.o FROM "dbrdf_FineArts_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FineArts" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FineArts"(s) SELECT DISTINCT t0.s FROM "dbrdf_FineArts_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_FineArts_delta_old";
        INSERT INTO "dbrdf_FineArts_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FineArts_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FineArts_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 48
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Chemical_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Chemical_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Chemical_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Chemical_EngineeringClass_delta_old" ON "dbrdf_Chemical_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Chemical_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Chemical_EngineeringClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Chemical_EngineeringClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Chemical_EngineeringClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Chemical_EngineeringClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Chemical_EngineeringClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Chemical_EngineeringClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Chemical_EngineeringClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Chemical_EngineeringClass_delta_old";
        INSERT INTO "dbrdf_Chemical_EngineeringClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Chemical_EngineeringClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Chemical_EngineeringClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 49
    ---- DEPENDS ON: 48, 35, 26, 17, 16, 14, 13, 12, 10, 6, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Engineering>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Chemical_EngineeringClass>(?X) .
    INSERT INTO "dbrdf_Engineering"(s) SELECT t0.s FROM "dbrdf_Chemical_EngineeringClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Engineering" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Engineering>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Industry_EngineeringClass>(?X) .
    INSERT INTO "dbrdf_Engineering"(s) SELECT t0.s FROM "dbrdf_Industry_EngineeringClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Engineering" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Engineering>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Computer_EngineeringClass>(?X) .
    INSERT INTO "dbrdf_Engineering"(s) SELECT t0.s FROM "dbrdf_Computer_EngineeringClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Engineering" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Engineering>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Biomedical_EngineeringClass>(?X) .
    INSERT INTO "dbrdf_Engineering"(s) SELECT t0.s FROM "dbrdf_Biomedical_EngineeringClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Engineering" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Engineering>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Civil_EngineeringClass>(?X) .
    INSERT INTO "dbrdf_Engineering"(s) SELECT t0.s FROM "dbrdf_Civil_EngineeringClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Engineering" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Engineering>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Aeronautical_EngineeringClass>(?X) .
    INSERT INTO "dbrdf_Engineering"(s) SELECT t0.s FROM "dbrdf_Aeronautical_EngineeringClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Engineering" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Engineering>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Materical_Science_EngineeringClass>(?X) .
    INSERT INTO "dbrdf_Engineering"(s) SELECT t0.s FROM "dbrdf_Materical_Science_EngineeringClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Engineering" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Engineering>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Mechanical_EngineeringClass>(?X) .
    INSERT INTO "dbrdf_Engineering"(s) SELECT t0.s FROM "dbrdf_Mechanical_EngineeringClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Engineering" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Engineering>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Petroleuml_EngineeringClass>(?X) .
    INSERT INTO "dbrdf_Engineering"(s) SELECT t0.s FROM "dbrdf_Petroleuml_EngineeringClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Engineering" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Engineering>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Electrical_EngineeringClass>(?X) .
    INSERT INTO "dbrdf_Engineering"(s) SELECT t0.s FROM "dbrdf_Electrical_EngineeringClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Engineering" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Engineering_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Engineering_delta_old"(s) SELECT t0.s FROM "dbrdf_Engineering" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Engineering_delta_old" ON "dbrdf_Engineering_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Engineering_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Engineering$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Engineering$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Engineering_delta_new"(s) SELECT t1.o FROM "dbrdf_Engineering_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Engineering" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Engineering"(s) SELECT DISTINCT t0.s FROM "dbrdf_Engineering_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Engineering_delta_old";
        INSERT INTO "dbrdf_Engineering_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Engineering_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Engineering_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 50
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Schedule>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#listedCourse>(?X,?X1) .
    INSERT INTO "dbrdf_Schedule"(s) SELECT DISTINCT t0.s FROM "dbrdf_listedCourse" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Schedule" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Schedule_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Schedule_delta_old"(s) SELECT t0.s FROM "dbrdf_Schedule" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Schedule_delta_old" ON "dbrdf_Schedule_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Schedule_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Schedule$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Schedule$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Schedule_delta_new"(s) SELECT t1.o FROM "dbrdf_Schedule_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Schedule" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Schedule"(s) SELECT DISTINCT t0.s FROM "dbrdf_Schedule_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Schedule_delta_old";
        INSERT INTO "dbrdf_Schedule_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Schedule_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Schedule_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 51
    ---- DEPENDS ON: 0, 30
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Work>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Research>(?X) .
    INSERT INTO "dbrdf_Work"(s) SELECT t0.s FROM "dbrdf_Research" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Work" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Work>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Course>(?X) .
    INSERT INTO "dbrdf_Work"(s) SELECT t0.s FROM "dbrdf_Course0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Work" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Work_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Work_delta_old"(s) SELECT t0.s FROM "dbrdf_Work" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Work_delta_old" ON "dbrdf_Work_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Work_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Work$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Work$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Work_delta_new"(s) SELECT t1.o FROM "dbrdf_Work_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Work" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Work"(s) SELECT DISTINCT t0.s FROM "dbrdf_Work_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Work_delta_old";
        INSERT INTO "dbrdf_Work_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Work_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Work_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 52
    ---- DEPENDS ON: 0, 8
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Insterest>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Music>(?X) .
    INSERT INTO "dbrdf_Insterest"(s) SELECT t0.s FROM "dbrdf_Music" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Insterest" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Insterest>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Sports>(?X) .
    INSERT INTO "dbrdf_Insterest"(s) SELECT t0.s FROM "dbrdf_Sports" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Insterest" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Insterest_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Insterest_delta_old"(s) SELECT t0.s FROM "dbrdf_Insterest" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Insterest_delta_old" ON "dbrdf_Insterest_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Insterest_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Insterest$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Insterest$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Insterest_delta_new"(s) SELECT t1.o FROM "dbrdf_Insterest_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Insterest" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Insterest"(s) SELECT DISTINCT t0.s FROM "dbrdf_Insterest_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Insterest_delta_old";
        INSERT INTO "dbrdf_Insterest_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Insterest_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Insterest_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 53
    ---- DEPENDS ON: 0, 49, 47, 43
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#AcademicSubject>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Science>(?X) .
    INSERT INTO "dbrdf_AcademicSubject"(s) SELECT t0.s FROM "dbrdf_Science" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_AcademicSubject" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#AcademicSubject>(?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasMajor>(?X,?X1) .
    INSERT INTO "dbrdf_AcademicSubject"(s) SELECT DISTINCT t0.o FROM "dbrdf_hasMajor" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_AcademicSubject" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#AcademicSubject>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Engineering>(?X) .
    INSERT INTO "dbrdf_AcademicSubject"(s) SELECT t0.s FROM "dbrdf_Engineering" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_AcademicSubject" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#AcademicSubject>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#FineArts>(?X) .
    INSERT INTO "dbrdf_AcademicSubject"(s) SELECT t0.s FROM "dbrdf_FineArts" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_AcademicSubject" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#AcademicSubject>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#HumanitiesAndSocial>(?X) .
    INSERT INTO "dbrdf_AcademicSubject"(s) SELECT t0.s FROM "dbrdf_HumanitiesAndSocial" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_AcademicSubject" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AcademicSubject_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AcademicSubject_delta_old"(s) SELECT t0.s FROM "dbrdf_AcademicSubject" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AcademicSubject_delta_old" ON "dbrdf_AcademicSubject_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AcademicSubject_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#AcademicSubject$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#AcademicSubject$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_AcademicSubject_delta_new"(s) SELECT t1.o FROM "dbrdf_AcademicSubject_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_AcademicSubject" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AcademicSubject"(s) SELECT DISTINCT t0.s FROM "dbrdf_AcademicSubject_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_AcademicSubject_delta_old";
        INSERT INTO "dbrdf_AcademicSubject_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AcademicSubject_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AcademicSubject_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 54
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Specification_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Specification_delta_old"(s) SELECT t0.s FROM "dbrdf_Specification" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Specification_delta_old" ON "dbrdf_Specification_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Specification_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Specification$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Specification$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Specification_delta_new"(s) SELECT t1.o FROM "dbrdf_Specification_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Specification" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Specification"(s) SELECT DISTINCT t0.s FROM "dbrdf_Specification_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Specification_delta_old";
        INSERT INTO "dbrdf_Specification_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Specification_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Specification_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 55
    ---- DEPENDS ON: 54, 36, 41, 29, 0, 24, 19, 38, 11, 1
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Publication>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Specification>(?X) .
    INSERT INTO "dbrdf_Publication0"(s) SELECT t0.s FROM "dbrdf_Specification" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Publication0" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Publication>(?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#softwareDocumentation>(?X,?X1) .
    INSERT INTO "dbrdf_Publication0"(s) SELECT DISTINCT t0.o FROM "dbrdf_softwareDocumentation" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Publication0" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Publication>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Article>(?X) .
    INSERT INTO "dbrdf_Publication0"(s) SELECT t0.s FROM "dbrdf_Article" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Publication0" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Publication>(?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#orgPublication>(?X,?X1) .
    INSERT INTO "dbrdf_Publication0"(s) SELECT DISTINCT t0.o FROM "dbrdf_orgPublication" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Publication0" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Publication>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#publicationAuthor>(?X,?X1) .
    INSERT INTO "dbrdf_Publication0"(s) SELECT DISTINCT t0.s FROM "dbrdf_publicationAuthor0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Publication0" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Publication>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#UnofficialPublication>(?X) .
    INSERT INTO "dbrdf_Publication0"(s) SELECT t0.s FROM "dbrdf_UnofficialPublication" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Publication0" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Publication>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#publicationResearch>(?X,?X1) .
    INSERT INTO "dbrdf_Publication0"(s) SELECT DISTINCT t0.s FROM "dbrdf_publicationResearch" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Publication0" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Publication>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Manual>(?X) .
    INSERT INTO "dbrdf_Publication0"(s) SELECT t0.s FROM "dbrdf_Manual" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Publication0" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Publication>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Software>(?X) .
    INSERT INTO "dbrdf_Publication0"(s) SELECT t0.s FROM "dbrdf_Software" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Publication0" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Publication>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Book>(?X) .
    INSERT INTO "dbrdf_Publication0"(s) SELECT t0.s FROM "dbrdf_Book" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Publication0" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Publication>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#publicationDate>(?X,?X1) .
    INSERT INTO "dbrdf_Publication0"(s) SELECT DISTINCT t0.s FROM "dbrdf_publicationDate" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Publication0" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Publication_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Publication_delta_old"(s) SELECT t0.s FROM "dbrdf_Publication0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Publication_delta_old" ON "dbrdf_Publication_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Publication_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Publication$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Publication$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Publication_delta_new"(s) SELECT t1.o FROM "dbrdf_Publication_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Publication0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Publication0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Publication_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Publication_delta_old";
        INSERT INTO "dbrdf_Publication_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Publication_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Publication_delta_new";

    END LOOP;

    -- END Recursive rules

    RETURN total_tuples;
END;
$$ LANGUAGE plpgsql;

-- END FUNCTION:   do_reasoning_all
------------------------------------------------------------------------------------------
