        TRUNCATE TABLE "dbrdf_AstronomyClass_delta_old";
        INSERT INTO "dbrdf_AstronomyClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AstronomyClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AstronomyClass_delta_new";

        INSERT INTO "dbrdf_enrollIn_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_enrollIn_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26507, t0.o FROM "dbrdf_enrollIn_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_enrollIn_delta_old";
        INSERT INTO "dbrdf_enrollIn_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_enrollIn_delta_new" t0;
        TRUNCATE TABLE "dbrdf_enrollIn_delta_new";

        INSERT INTO "dbrdf_isAffiliateOf_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isAffiliateOf_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26508, t0.o FROM "dbrdf_isAffiliateOf_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_isAffiliateOf_delta_old";
        INSERT INTO "dbrdf_isAffiliateOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isAffiliateOf_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isAffiliateOf_delta_new";

        INSERT INTO "dbrdf_isAffiliatedOrganizationOf_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isAffiliatedOrganizationOf_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26509, t0.o FROM "dbrdf_isAffiliatedOrganizationOf_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_isAffiliatedOrganizationOf_delta_old";
        INSERT INTO "dbrdf_isAffiliatedOrganizationOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isAffiliatedOrganizationOf_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isAffiliatedOrganizationOf_delta_new";

        INSERT INTO "dbrdf_hasMasterDegreeFrom_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasMasterDegreeFrom_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26510, t0.o FROM "dbrdf_hasMasterDegreeFrom_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_hasMasterDegreeFrom_delta_old";
        INSERT INTO "dbrdf_hasMasterDegreeFrom_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasMasterDegreeFrom_delta_new" t0;
        TRUNCATE TABLE "dbrdf_hasMasterDegreeFrom_delta_new";

        INSERT INTO "dbrdf_Materials_ScienceClass_old"(s) SELECT t0.s FROM "dbrdf_Materials_ScienceClass_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26511 FROM "dbrdf_Materials_ScienceClass_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_Materials_ScienceClass_delta_old";
        INSERT INTO "dbrdf_Materials_ScienceClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Materials_ScienceClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Materials_ScienceClass_delta_new";

        INSERT INTO "dbrdf_isAdvisedBy_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isAdvisedBy_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26512, t0.o FROM "dbrdf_isAdvisedBy_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_isAdvisedBy_delta_old";
        INSERT INTO "dbrdf_isAdvisedBy_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isAdvisedBy_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isAdvisedBy_delta_new";

        INSERT INTO "dbrdf_ResearchGroup_old"(s) SELECT t0.s FROM "dbrdf_ResearchGroup_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26513 FROM "dbrdf_ResearchGroup_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_ResearchGroup_delta_old";
        INSERT INTO "dbrdf_ResearchGroup_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ResearchGroup_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ResearchGroup_delta_new";

        INSERT INTO "dbrdf_NR10_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR10_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26514, t0.o FROM "dbrdf_NR10_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_NR10_delta_old";
        INSERT INTO "dbrdf_NR10_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR10_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR10_delta_new";

        INSERT INTO "dbrdf_firstName_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstName_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26516, t0.o FROM "dbrdf_firstName_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_firstName_delta_old";
        INSERT INTO "dbrdf_firstName_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstName_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstName_delta_new";

        INSERT INTO "dbrdf_NR5_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR5_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26517, t0.o FROM "dbrdf_NR5_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_NR5_delta_old";
        INSERT INTO "dbrdf_NR5_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR5_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR5_delta_new";

        INSERT INTO "dbrdf_BaseballFan_old"(s) SELECT t0.s FROM "dbrdf_BaseballFan_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26519 FROM "dbrdf_BaseballFan_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_BaseballFan_delta_old";
        INSERT INTO "dbrdf_BaseballFan_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballFan_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BaseballFan_delta_new";

        INSERT INTO "dbrdf_BaseballLover_old"(s) SELECT t0.s FROM "dbrdf_BaseballLover_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26522 FROM "dbrdf_BaseballLover_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_BaseballLover_delta_old";
        INSERT INTO "dbrdf_BaseballLover_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballLover_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BaseballLover_delta_new";

        INSERT INTO "dbrdf_BaseballClass_old"(s) SELECT t0.s FROM "dbrdf_BaseballClass_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26521 FROM "dbrdf_BaseballClass_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_BaseballClass_delta_old";
        INSERT INTO "dbrdf_BaseballClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BaseballClass_delta_new";

        INSERT INTO "dbrdf_NR2_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR2_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26523, t0.o FROM "dbrdf_NR2_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_NR2_delta_old";
        INSERT INTO "dbrdf_NR2_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR2_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR2_delta_new";

        INSERT INTO "dbrdf_hasAlumnus_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasAlumnus_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26525, t0.o FROM "dbrdf_hasAlumnus_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_hasAlumnus_delta_old";
        INSERT INTO "dbrdf_hasAlumnus_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasAlumnus_delta_new" t0;
        TRUNCATE TABLE "dbrdf_hasAlumnus_delta_new";

        INSERT INTO "dbrdf_University_old"(s) SELECT t0.s FROM "dbrdf_University_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26527 FROM "dbrdf_University_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_University_delta_old";
        INSERT INTO "dbrdf_University_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_University_delta_new" t0;
        TRUNCATE TABLE "dbrdf_University_delta_new";

        INSERT INTO "dbrdf_hasDegreeFrom_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasDegreeFrom_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26526, t0.o FROM "dbrdf_hasDegreeFrom_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_hasDegreeFrom_delta_old";
        INSERT INTO "dbrdf_hasDegreeFrom_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasDegreeFrom_delta_new" t0;
        TRUNCATE TABLE "dbrdf_hasDegreeFrom_delta_new";

        INSERT INTO "dbrdf_Program_old"(s) SELECT t0.s FROM "dbrdf_Program_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26528 FROM "dbrdf_Program_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_Program_delta_old";
        INSERT INTO "dbrdf_Program_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Program_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Program_delta_new";

        INSERT INTO "dbrdf_NR24_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR24_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26529, t0.o FROM "dbrdf_NR24_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_NR24_delta_old";
        INSERT INTO "dbrdf_NR24_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR24_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR24_delta_new";

        INSERT INTO "dbrdf_Director_old"(s) SELECT t0.s FROM "dbrdf_Director_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26531 FROM "dbrdf_Director_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_Director_delta_old";
        INSERT INTO "dbrdf_Director_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Director_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Director_delta_new";

        INSERT INTO "dbrdf_Man_old"(s) SELECT t0.s FROM "dbrdf_Man_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26533 FROM "dbrdf_Man_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_Man_delta_old";
        INSERT INTO "dbrdf_Man_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Man_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Man_delta_new";

        INSERT INTO "dbrdf_NR3_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR3_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26534, t0.o FROM "dbrdf_NR3_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_NR3_delta_old";
        INSERT INTO "dbrdf_NR3_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR3_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR3_delta_new";

        INSERT INTO "dbrdf_NR4_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR4_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26537, t0.o FROM "dbrdf_NR4_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_NR4_delta_old";
        INSERT INTO "dbrdf_NR4_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR4_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR4_delta_new";

        INSERT INTO "dbrdf_WomanCollege_old"(s) SELECT t0.s FROM "dbrdf_WomanCollege_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26539 FROM "dbrdf_WomanCollege_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_WomanCollege_delta_old";
        INSERT INTO "dbrdf_WomanCollege_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_WomanCollege_delta_new" t0;
        TRUNCATE TABLE "dbrdf_WomanCollege_delta_new";

        INSERT INTO "dbrdf_College_old"(s) SELECT t0.s FROM "dbrdf_College_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26536 FROM "dbrdf_College_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_College_delta_old";
        INSERT INTO "dbrdf_College_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_College_delta_new" t0;
        TRUNCATE TABLE "dbrdf_College_delta_new";

        INSERT INTO "dbrdf_NR25_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR25_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26540, t0.o FROM "dbrdf_NR25_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_NR25_delta_old";
        INSERT INTO "dbrdf_NR25_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR25_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR25_delta_new";

        INSERT INTO "dbrdf_Dean_old"(s) SELECT t0.s FROM "dbrdf_Dean_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26542 FROM "dbrdf_Dean_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_Dean_delta_old";
        INSERT INTO "dbrdf_Dean_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Dean_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Dean_delta_new";

        INSERT INTO "dbrdf_Department_old"(s) SELECT t0.s FROM "dbrdf_Department_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26543 FROM "dbrdf_Department_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_Department_delta_old";
        INSERT INTO "dbrdf_Department_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Department_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Department_delta_new";

        INSERT INTO "dbrdf_NR23_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_NR23_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26544, t0.o FROM "dbrdf_NR23_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_NR23_delta_old";
        INSERT INTO "dbrdf_NR23_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_NR23_delta_new" t0;
        TRUNCATE TABLE "dbrdf_NR23_delta_new";

        INSERT INTO "dbrdf_Faculty_old"(s) SELECT t0.s FROM "dbrdf_Faculty_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26547 FROM "dbrdf_Faculty_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_Faculty_delta_old";
        INSERT INTO "dbrdf_Faculty_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Faculty_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Faculty_delta_new";

        INSERT INTO "dbrdf_Professor_old"(s) SELECT t0.s FROM "dbrdf_Professor_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26548 FROM "dbrdf_Professor_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_Professor_delta_old";
        INSERT INTO "dbrdf_Professor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Professor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Professor_delta_new";

        INSERT INTO "dbrdf_Chair_old"(s) SELECT t0.s FROM "dbrdf_Chair_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26546 FROM "dbrdf_Chair_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_Chair_delta_old";
        INSERT INTO "dbrdf_Chair_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Chair_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Chair_delta_new";

        INSERT INTO "dbrdf_isHeadOf_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isHeadOf_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26532, t0.o FROM "dbrdf_isHeadOf_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_isHeadOf_delta_old";
        INSERT INTO "dbrdf_isHeadOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isHeadOf_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isHeadOf_delta_new";

        INSERT INTO "dbrdf_listedCourse_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_listedCourse_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26549, t0.o FROM "dbrdf_listedCourse_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_listedCourse_delta_old";
        INSERT INTO "dbrdf_listedCourse_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_listedCourse_delta_new" t0;
        TRUNCATE TABLE "dbrdf_listedCourse_delta_new";

        INSERT INTO "dbrdf_teachingAssistantOf_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_teachingAssistantOf_delta_old" t0;
        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26550, t0.o FROM "dbrdf_teachingAssistantOf_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_teachingAssistantOf_delta_old";
        INSERT INTO "dbrdf_teachingAssistantOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_teachingAssistantOf_delta_new" t0;
        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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26551, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26553 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26554 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26555, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26557 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26559, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26561 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26558 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26565 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26563 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26566, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26459, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26568 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26461, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26569, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26576 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26564 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26577, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26579 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26520, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26580, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26582 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26562 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26573, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26584 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26585 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26587, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26589 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26590 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26588, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26593 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26594, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26595, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26596, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26586 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26598 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26599, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26601, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26602, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 26600, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26604 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26477 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 "__triples" t0 WHERE t0.p = 26605;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26605 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26605 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26605, 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26606;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26606);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26606 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26607;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26607);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26607 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26608;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26608);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26608 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26609;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26609);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26609 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_DramaClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_DramaClass_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26610;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26610);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26610 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 7
    ---- 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26611;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26611);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26611 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 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26612;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26612);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26612 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_Petroleuml_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Petroleuml_EngineeringClass_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26613;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26613);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26613 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 10
    ---- 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26614;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26614);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26614 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 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26615;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26615);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26615 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26616;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26616);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26616 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26617;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26617);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26617 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26618;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26618);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26618 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26619;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26619);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26619 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26620;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26620);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26620 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26621;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26621);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26621 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26622;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26622);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26622 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26623;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26623);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26623 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26624;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26624);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26624 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26625;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26625);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26625 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26626;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26626);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26626 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26627;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26627);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26627 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26628;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26628);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26628 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26629;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26629);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26629 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26630;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26630);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26630 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26631;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26631);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26631 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26632;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26632);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26632 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 "__triples" t0 WHERE t0.p = 26633;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26633 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26633 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26633, 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 "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 26634 FROM "__triples" t0 WHERE t0.p = 26633 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 26634);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 26634 FROM "__triples" t0 WHERE t0.p = 26465 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 26634);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26634;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26634);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26634 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26635;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26635);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26635 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26636;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26636);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26636 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26637;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26637);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26637 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26638;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26638);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26638 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26639;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26639);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26639 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 "__triples" t0 WHERE t0.p = 26640;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26640 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26640 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26640, 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 "__triples" t0 WHERE t0.p = 26641;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26641 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26641 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26641, 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26642 FROM "__triples" t0 WHERE t0.p = 26641 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26642);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26642 FROM "__triples" t0 WHERE t0.p = 26640 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26642);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26642;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26642);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26642 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_JournalArticle_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_JournalArticle_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26643;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26643);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26643 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 40
    ---- DEPENDS ON: 39, 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 "__triples"(s, p, o) SELECT t0.s, 2, 26644 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26643 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26644);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26644 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26632 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26644);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26644 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26625 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26644);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26644;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26644);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26644 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 41
    ---- 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26645;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26645);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26645 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 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26646;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26646);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26646 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, 41, 32, 31, 27, 25, 20, 15, 10, 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 "__triples"(s, p, o) SELECT t0.s, 2, 26647 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26646 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26647);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26647 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26645 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26647);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26647 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26636 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26647);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26647 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26635 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26647);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26647 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26631 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26647);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26647 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26629 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26647);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26647 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26624 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26647);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26647 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26619 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26647);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26647 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26614 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26647);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26647 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26609 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26647);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26647;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26647);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26647 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 "__triples" t0 WHERE t0.p = 26648;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26648 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, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26648 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26648, 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 "__triples"(s, p, o) SELECT DISTINCT 26649, 2, 26650 FROM "__triples" t0, "__triples" t1 WHERE t0.s = t1.o AND t0.p = 26648 AND t0.o = 26651 AND t1.p = 26516 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = 26649 AND ex.p = 2 AND ex.o = 26650);
    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 "__triples"(s, p, o) SELECT DISTINCT 26649, 2, 26650 FROM "__triples" t0, "__triples" t1 WHERE t0.s = t1.o AND t0.p = 26648 AND t0.o = 26651 AND t1.p = 26495 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = 26649 AND ex.p = 2 AND ex.o = 26650);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26650;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26650);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26650 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26652;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26652);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26652 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, 6, 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 "__triples"(s, p, o) SELECT t0.s, 2, 26653 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26652 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26653);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26653 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26638 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26653);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26653 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26637 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26653);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26653 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26627 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26653);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26653 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26626 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26653);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26653 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26622 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26653);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26653 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26610 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26653);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26653 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26608 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26653);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26653 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26607 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26653);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26653 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26606 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26653);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26653;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26653);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26653 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26654;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26654);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26654 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, 9, 7, 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 "__triples"(s, p, o) SELECT t0.s, 2, 26655 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26654 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26655);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26655 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26639 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26655);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26655 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26630 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26655);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26655 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26621 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26655);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26655 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26620 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26655);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26655 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26618 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26655);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26655 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26617 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26655);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26655 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26616 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26655);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26655 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26613 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26655);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26655 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26611 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26655);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26655;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26655);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26655 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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26656 FROM "__triples" t0 WHERE t0.p = 26549 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26656);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26656;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26656);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26656 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 "__triples"(s, p, o) SELECT t0.s, 2, 26657 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26634 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26657);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26657 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26554 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26657);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26657;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26657);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26657 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 "__triples"(s, p, o) SELECT t0.s, 2, 26658 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26612 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26658);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26658 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26558 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26658);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26658;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26658);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26658 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 "__triples"(s, p, o) SELECT t0.s, 2, 26659 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26590 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26659);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 26659 FROM "__triples" t0 WHERE t0.p = 26587 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 26659);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26659 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26655 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26659);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26659 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26653 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26659);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26659 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26647 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26659);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26659;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26659);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26659 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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26660;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26660);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26660 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, 40, 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 "__triples"(s, p, o) SELECT t0.s, 2, 26661 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26660 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26661);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 26661 FROM "__triples" t0 WHERE t0.p = 26640 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 26661);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26661 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26644 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26661);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.o, 2, 26661 FROM "__triples" t0 WHERE t0.p = 26498 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.o AND ex.p = 2 AND ex.o = 26661);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26661 FROM "__triples" t0 WHERE t0.p = 26494 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26661);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26661 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26628 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26661);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26661 FROM "__triples" t0 WHERE t0.p = 26633 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26661);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26661 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26623 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26661);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26661 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26642 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26661);
    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 "__triples"(s, p, o) SELECT t0.s, 2, 26661 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26615 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26661);
    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 "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26661 FROM "__triples" t0 WHERE t0.p = 26605 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26661);
    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 "__triples" t0 WHERE t0.p = 2 AND t0.o = 26661;
    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, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26661);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26661 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
------------------------------------------------------------------------------------------
