------------------------------------------------------------------------------------------
-- START FUNCTION: do_reasoning_all

CREATE OR REPLACE FUNCTION do_reasoning_all() RETURNS integer AS $$
DECLARE
    rows_nr integer;
    delta_old_size integer;
    total_tuples integer;
BEGIN
    total_tuples := 0;

    ----------------------------------------
    ---- COMPONENT 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isTaughtBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isTaughtBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isTaughtBy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isTaughtBy_delta_old" ON "dbrdf_isTaughtBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isTaughtBy_delta_old" ON "dbrdf_isTaughtBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isTaughtBy_old"(s integer, o integer) ON COMMIT DROP;
    CREATE INDEX "IDX_0_dbrdf_isTaughtBy_old" ON "dbrdf_isTaughtBy_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isTaughtBy_old" ON "dbrdf_isTaughtBy_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isTaughtBy_delta_new"(s integer, o integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_teacherOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_teacherOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_teacherOf0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_teacherOf_delta_old" ON "dbrdf_teacherOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_teacherOf_delta_old" ON "dbrdf_teacherOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_teacherOf_old"(s integer, o integer) ON COMMIT DROP;
    CREATE INDEX "IDX_0_dbrdf_teacherOf_old" ON "dbrdf_teacherOf_old"(s, o); CREATE INDEX "IDX_1_dbrdf_teacherOf_old" ON "dbrdf_teacherOf_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_teacherOf_delta_new"(s integer, o integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isHeadOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isHeadOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isHeadOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isHeadOf_delta_old" ON "dbrdf_isHeadOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isHeadOf_delta_old" ON "dbrdf_isHeadOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isHeadOf_old"(s integer, o integer) ON COMMIT DROP;
    CREATE INDEX "IDX_0_dbrdf_isHeadOf_old" ON "dbrdf_isHeadOf_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isHeadOf_old" ON "dbrdf_isHeadOf_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isHeadOf_delta_new"(s integer, o integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sameAs_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sameAs_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sameAs" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sameAs_delta_old" ON "dbrdf_sameAs_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sameAs_delta_old" ON "dbrdf_sameAs_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sameAs_old"(s integer, o integer) ON COMMIT DROP;
    CREATE INDEX "IDX_0_dbrdf_sameAs_old" ON "dbrdf_sameAs_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sameAs_old" ON "dbrdf_sameAs_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sameAs_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#isTaughtBy$delta_new>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#teacherOf$delta_old>(?Y,?X) .
        INSERT INTO "dbrdf_isTaughtBy_delta_new"(s, o) SELECT t0.o, t0.s FROM "dbrdf_teacherOf_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_isTaughtBy" ex WHERE ex.s = t0.o AND ex.o = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isTaughtBy$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isTaughtBy>(?X0,?X1), <http://www.w3.org/2002/07/owl#sameAs$delta_old>(?X0,?Y) .
        INSERT INTO "dbrdf_isTaughtBy_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_isTaughtBy" t0, "dbrdf_sameAs_delta_old" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_isTaughtBy" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isTaughtBy$delta_new>(?X0,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isTaughtBy>(?X0,?X1), <http://www.w3.org/2002/07/owl#sameAs$delta_old>(?X1,?Y) .
        INSERT INTO "dbrdf_isTaughtBy_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_isTaughtBy" t0, "dbrdf_sameAs_delta_old" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_isTaughtBy" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#teacherOf$delta_new>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isTaughtBy$delta_old>(?Y,?X) .
        INSERT INTO "dbrdf_teacherOf_delta_new"(s, o) SELECT t0.o, t0.s FROM "dbrdf_isTaughtBy_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_teacherOf0" ex WHERE ex.s = t0.o AND ex.o = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#teacherOf$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#teacherOf>(?X0,?X1), <http://www.w3.org/2002/07/owl#sameAs$delta_old>(?X0,?Y) .
        INSERT INTO "dbrdf_teacherOf_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_teacherOf0" t0, "dbrdf_sameAs_delta_old" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_teacherOf0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#teacherOf$delta_new>(?X0,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#teacherOf>(?X0,?X1), <http://www.w3.org/2002/07/owl#sameAs$delta_old>(?X1,?Y) .
        INSERT INTO "dbrdf_teacherOf_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_teacherOf0" t0, "dbrdf_sameAs_delta_old" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_teacherOf0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isHeadOf$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isHeadOf>(?X0,?X1), <http://www.w3.org/2002/07/owl#sameAs$delta_old>(?X0,?Y) .
        INSERT INTO "dbrdf_isHeadOf_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_isHeadOf" t0, "dbrdf_sameAs_delta_old" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_isHeadOf" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isHeadOf$delta_new>(?X0,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isHeadOf>(?X0,?X1), <http://www.w3.org/2002/07/owl#sameAs$delta_old>(?X1,?Y) .
        INSERT INTO "dbrdf_isHeadOf_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_isHeadOf" t0, "dbrdf_sameAs_delta_old" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_isHeadOf" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- <http://www.w3.org/2002/07/owl#sameAs$delta_new>(?Y1,?Y2) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isHeadOf$delta_old>(?Y1,?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#isHeadOf>(?Y2,?X) .
        INSERT INTO "dbrdf_sameAs_delta_new"(s, o) SELECT t0.s, t1.s FROM "dbrdf_isHeadOf_delta_old" t0, "dbrdf_isHeadOf" t1 WHERE t0.o = t1.o AND NOT EXISTS (SELECT 1 FROM "dbrdf_sameAs" ex WHERE ex.s = t0.s AND ex.o = t1.s);


        -- <http://www.w3.org/2002/07/owl#sameAs$delta_new>(?Y1,?Y2) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isHeadOf>(?Y1,?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#isHeadOf$delta_old>(?Y2,?X) .
        INSERT INTO "dbrdf_sameAs_delta_new"(s, o) SELECT t0.s, t1.s FROM "dbrdf_isHeadOf" t0, "dbrdf_isHeadOf_delta_old" t1 WHERE t0.o = t1.o AND NOT EXISTS (SELECT 1 FROM "dbrdf_sameAs" ex WHERE ex.s = t0.s AND ex.o = t1.s);


        -- <http://www.w3.org/2002/07/owl#sameAs$delta_new>(?Y1,?Y2) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isTaughtBy$delta_old>(?X,?Y1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#isTaughtBy>(?X,?Y2) .
        INSERT INTO "dbrdf_sameAs_delta_new"(s, o) SELECT t0.o, t1.o FROM "dbrdf_isTaughtBy_delta_old" t0, "dbrdf_isTaughtBy" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_sameAs" ex WHERE ex.s = t0.o AND ex.o = t1.o);


        -- <http://www.w3.org/2002/07/owl#sameAs$delta_new>(?Y1,?Y2) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isTaughtBy>(?X,?Y1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#isTaughtBy$delta_old>(?X,?Y2) .
        INSERT INTO "dbrdf_sameAs_delta_new"(s, o) SELECT t0.o, t1.o FROM "dbrdf_isTaughtBy" t0, "dbrdf_isTaughtBy_delta_old" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_sameAs" ex WHERE ex.s = t0.o AND ex.o = t1.o);


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


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_isTaughtBy_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isTaughtBy_delta_old" t0;
        INSERT INTO "dbrdf_isTaughtBy"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isTaughtBy_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_isTaughtBy_delta_old";
        INSERT INTO "dbrdf_isTaughtBy_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isTaughtBy_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isTaughtBy_delta_new";

        INSERT INTO "dbrdf_teacherOf_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_teacherOf_delta_old" t0;
        INSERT INTO "dbrdf_teacherOf0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_teacherOf_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_teacherOf_delta_old";
        INSERT INTO "dbrdf_teacherOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_teacherOf_delta_new" t0;
        TRUNCATE TABLE "dbrdf_teacherOf_delta_new";

        INSERT INTO "dbrdf_isHeadOf_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isHeadOf_delta_old" t0;
        INSERT INTO "dbrdf_isHeadOf"(s, o) SELECT DISTINCT t0.s, 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_sameAs_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sameAs_delta_old" t0;
        INSERT INTO "dbrdf_sameAs"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sameAs_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_sameAs_delta_old";
        INSERT INTO "dbrdf_sameAs_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sameAs_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sameAs_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 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 "dbrdf_Electrical_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Electrical_EngineeringClass_delta_old" ON "dbrdf_Electrical_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Electrical_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ResearchAssistant_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ResearchAssistant_delta_old"(s) SELECT t0.s FROM "dbrdf_ResearchAssistant0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ResearchAssistant_delta_old" ON "dbrdf_ResearchAssistant_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ResearchAssistant_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#ResearchAssistant$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ResearchAssistant$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ResearchAssistant_delta_new"(s) SELECT t1.o FROM "dbrdf_ResearchAssistant_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ResearchAssistant0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ResearchAssistant0"(s) SELECT DISTINCT t0.s FROM "dbrdf_ResearchAssistant_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_ResearchAssistant_delta_old";
        INSERT INTO "dbrdf_ResearchAssistant_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ResearchAssistant_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ResearchAssistant_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_Computer_ScienceClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Computer_ScienceClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Computer_ScienceClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Computer_ScienceClass_delta_old" ON "dbrdf_Computer_ScienceClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Computer_ScienceClass_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_ScienceClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Computer_ScienceClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Computer_ScienceClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Computer_ScienceClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Computer_ScienceClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Computer_ScienceClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Computer_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_Computer_ScienceClass_delta_old";
        INSERT INTO "dbrdf_Computer_ScienceClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Computer_ScienceClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Computer_ScienceClass_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_Petroleuml_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Petroleuml_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Petroleuml_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Petroleuml_EngineeringClass_delta_old" ON "dbrdf_Petroleuml_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Petroleuml_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Program_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Program_delta_old"(s) SELECT t0.s FROM "dbrdf_Program" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Program_delta_old" ON "dbrdf_Program_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Program_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#Program$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Program$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Program_delta_new"(s) SELECT t1.o FROM "dbrdf_Program_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Program" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Program"(s) SELECT DISTINCT t0.s 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";

    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_SystemsStaff_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SystemsStaff_delta_old"(s) SELECT t0.s FROM "dbrdf_SystemsStaff" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SystemsStaff_delta_old" ON "dbrdf_SystemsStaff_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SystemsStaff_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#SystemsStaff$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#SystemsStaff$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SystemsStaff_delta_new"(s) SELECT t1.o FROM "dbrdf_SystemsStaff_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SystemsStaff" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SystemsStaff"(s) SELECT DISTINCT t0.s FROM "dbrdf_SystemsStaff_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_SystemsStaff_delta_old";
        INSERT INTO "dbrdf_SystemsStaff_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SystemsStaff_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SystemsStaff_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_Mechanical_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Mechanical_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Mechanical_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Mechanical_EngineeringClass_delta_old" ON "dbrdf_Mechanical_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Mechanical_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_StatisticsClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_StatisticsClass_delta_old"(s) SELECT t0.s FROM "dbrdf_StatisticsClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_StatisticsClass_delta_old" ON "dbrdf_StatisticsClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_StatisticsClass_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#StatisticsClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#StatisticsClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_StatisticsClass_delta_new"(s) SELECT t1.o FROM "dbrdf_StatisticsClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_StatisticsClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_StatisticsClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_StatisticsClass_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_StatisticsClass_delta_old";
        INSERT INTO "dbrdf_StatisticsClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_StatisticsClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_StatisticsClass_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_Materical_Science_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Materical_Science_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Materical_Science_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Materical_Science_EngineeringClass_delta_old" ON "dbrdf_Materical_Science_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Materical_Science_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_tenured_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_tenured_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_tenured" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_tenured_delta_old" ON "dbrdf_tenured_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_tenured_delta_old" ON "dbrdf_tenured_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_tenured_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#tenured$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#tenured$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_tenured_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_tenured_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_tenured" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_tenured"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_tenured_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_tenured_delta_old";
        INSERT INTO "dbrdf_tenured_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_tenured_delta_new" t0;
        TRUNCATE TABLE "dbrdf_tenured_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_researchProject_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_researchProject_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_researchProject" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_researchProject_delta_old" ON "dbrdf_researchProject_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_researchProject_delta_old" ON "dbrdf_researchProject_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_researchProject_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#researchProject$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#researchProject$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_researchProject_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_researchProject_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_researchProject" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_researchProject"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_researchProject_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_researchProject_delta_old";
        INSERT INTO "dbrdf_researchProject_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_researchProject_delta_new" t0;
        TRUNCATE TABLE "dbrdf_researchProject_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_hasUndergraduateDegreeFrom_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasUndergraduateDegreeFrom_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasUndergraduateDegreeFrom" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasUndergraduateDegreeFrom_delta_old" ON "dbrdf_hasUndergraduateDegreeFrom_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasUndergraduateDegreeFrom_delta_old" ON "dbrdf_hasUndergraduateDegreeFrom_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasUndergraduateDegreeFrom_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#hasUndergraduateDegreeFrom$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasUndergraduateDegreeFrom$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_hasUndergraduateDegreeFrom_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_hasUndergraduateDegreeFrom_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_hasUndergraduateDegreeFrom" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_hasUndergraduateDegreeFrom"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasUndergraduateDegreeFrom_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_hasUndergraduateDegreeFrom_delta_old";
        INSERT INTO "dbrdf_hasUndergraduateDegreeFrom_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasUndergraduateDegreeFrom_delta_new" t0;
        TRUNCATE TABLE "dbrdf_hasUndergraduateDegreeFrom_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_Aeronautical_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Aeronautical_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Aeronautical_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Aeronautical_EngineeringClass_delta_old" ON "dbrdf_Aeronautical_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Aeronautical_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_emailAddress_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_emailAddress_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_emailAddress0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_emailAddress_delta_old" ON "dbrdf_emailAddress_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_emailAddress_delta_old" ON "dbrdf_emailAddress_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_emailAddress_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#emailAddress$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#emailAddress$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_emailAddress_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_emailAddress_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_emailAddress0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_emailAddress0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_emailAddress_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_emailAddress_delta_old";
        INSERT INTO "dbrdf_emailAddress_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_emailAddress_delta_new" t0;
        TRUNCATE TABLE "dbrdf_emailAddress_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_ClericalStaff_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ClericalStaff_delta_old"(s) SELECT t0.s FROM "dbrdf_ClericalStaff" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ClericalStaff_delta_old" ON "dbrdf_ClericalStaff_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ClericalStaff_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#ClericalStaff$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ClericalStaff$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ClericalStaff_delta_new"(s) SELECT t1.o FROM "dbrdf_ClericalStaff_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ClericalStaff" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ClericalStaff"(s) SELECT DISTINCT t0.s FROM "dbrdf_ClericalStaff_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_ClericalStaff_delta_old";
        INSERT INTO "dbrdf_ClericalStaff_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ClericalStaff_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ClericalStaff_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_AssistantProfessor_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AssistantProfessor_delta_old"(s) SELECT t0.s FROM "dbrdf_AssistantProfessor0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AssistantProfessor_delta_old" ON "dbrdf_AssistantProfessor_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AssistantProfessor_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#AssistantProfessor$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#AssistantProfessor$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_AssistantProfessor_delta_new"(s) SELECT t1.o FROM "dbrdf_AssistantProfessor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_AssistantProfessor0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AssistantProfessor0"(s) SELECT DISTINCT t0.s FROM "dbrdf_AssistantProfessor_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_AssistantProfessor_delta_old";
        INSERT INTO "dbrdf_AssistantProfessor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AssistantProfessor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AssistantProfessor_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_Civil_EngineeringClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Civil_EngineeringClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Civil_EngineeringClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Civil_EngineeringClass_delta_old" ON "dbrdf_Civil_EngineeringClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Civil_EngineeringClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_PhysicsClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PhysicsClass_delta_old"(s) SELECT t0.s FROM "dbrdf_PhysicsClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PhysicsClass_delta_old" ON "dbrdf_PhysicsClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PhysicsClass_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#PhysicsClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#PhysicsClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PhysicsClass_delta_new"(s) SELECT t1.o FROM "dbrdf_PhysicsClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PhysicsClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PhysicsClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_PhysicsClass_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_PhysicsClass_delta_old";
        INSERT INTO "dbrdf_PhysicsClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PhysicsClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PhysicsClass_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_isFriendOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isFriendOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isFriendOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isFriendOf_delta_old" ON "dbrdf_isFriendOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isFriendOf_delta_old" ON "dbrdf_isFriendOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isFriendOf_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#isFriendOf$delta_new>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isFriendOf$delta_old>(?Y,?X) .
        INSERT INTO "dbrdf_isFriendOf_delta_new"(s, o) SELECT t0.o, t0.s FROM "dbrdf_isFriendOf_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_isFriendOf" ex WHERE ex.s = t0.o AND ex.o = t0.s);


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_isFriendOf"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isFriendOf_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_isFriendOf_delta_old";
        INSERT INTO "dbrdf_isFriendOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isFriendOf_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isFriendOf_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 30
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_VisitingProfessor_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_VisitingProfessor_delta_old"(s) SELECT t0.s FROM "dbrdf_VisitingProfessor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_VisitingProfessor_delta_old" ON "dbrdf_VisitingProfessor_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_VisitingProfessor_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#VisitingProfessor$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#VisitingProfessor$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_VisitingProfessor_delta_new"(s) SELECT t1.o FROM "dbrdf_VisitingProfessor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_VisitingProfessor" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_VisitingProfessor"(s) SELECT DISTINCT t0.s FROM "dbrdf_VisitingProfessor_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_VisitingProfessor_delta_old";
        INSERT INTO "dbrdf_VisitingProfessor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_VisitingProfessor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_VisitingProfessor_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_FullProfessor_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_FullProfessor_delta_old"(s) SELECT t0.s FROM "dbrdf_FullProfessor0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_FullProfessor_delta_old" ON "dbrdf_FullProfessor_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_FullProfessor_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#FullProfessor$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#FullProfessor$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_FullProfessor_delta_new"(s) SELECT t1.o FROM "dbrdf_FullProfessor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_FullProfessor0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_FullProfessor0"(s) SELECT DISTINCT t0.s FROM "dbrdf_FullProfessor_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_FullProfessor_delta_old";
        INSERT INTO "dbrdf_FullProfessor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_FullProfessor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_FullProfessor_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_Theatre_and_DanceClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Theatre_and_DanceClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Theatre_and_DanceClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Theatre_and_DanceClass_delta_old" ON "dbrdf_Theatre_and_DanceClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Theatre_and_DanceClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 34
    ---- DEPENDS ON: 20, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ResearchGroup_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ResearchGroup_delta_old"(s) SELECT t0.s FROM "dbrdf_ResearchGroup0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ResearchGroup_delta_old" ON "dbrdf_ResearchGroup_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ResearchGroup_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#ResearchGroup$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ResearchGroup$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ResearchGroup_delta_new"(s) SELECT t1.o FROM "dbrdf_ResearchGroup_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ResearchGroup0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ResearchGroup0"(s) SELECT DISTINCT t0.s 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";

    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_Lecturer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Lecturer_delta_old"(s) SELECT t0.s FROM "dbrdf_Lecturer0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Lecturer_delta_old" ON "dbrdf_Lecturer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Lecturer_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#Lecturer$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Lecturer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Lecturer_delta_new"(s) SELECT t1.o FROM "dbrdf_Lecturer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Lecturer0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Lecturer0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lecturer_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_Lecturer_delta_old";
        INSERT INTO "dbrdf_Lecturer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lecturer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Lecturer_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_Woman_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Woman_delta_old"(s) SELECT t0.s FROM "dbrdf_Woman" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Woman_delta_old" ON "dbrdf_Woman_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Woman_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#Woman$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Woman$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Woman_delta_new"(s) SELECT t1.o FROM "dbrdf_Woman_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Woman" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Woman"(s) SELECT DISTINCT t0.s FROM "dbrdf_Woman_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_Woman_delta_old";
        INSERT INTO "dbrdf_Woman_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Woman_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Woman_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_Manual_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Manual_delta_old"(s) SELECT t0.s FROM "dbrdf_Manual" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Manual_delta_old" ON "dbrdf_Manual_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Manual_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 38
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 41
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChemistryClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ChemistryClass_delta_old"(s) SELECT t0.s FROM "dbrdf_ChemistryClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ChemistryClass_delta_old" ON "dbrdf_ChemistryClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChemistryClass_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#ChemistryClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ChemistryClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ChemistryClass_delta_new"(s) SELECT t1.o FROM "dbrdf_ChemistryClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ChemistryClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ChemistryClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemistryClass_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_ChemistryClass_delta_old";
        INSERT INTO "dbrdf_ChemistryClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemistryClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ChemistryClass_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_TennisClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TennisClass_delta_old"(s) SELECT t0.s FROM "dbrdf_TennisClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TennisClass_delta_old" ON "dbrdf_TennisClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TennisClass_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#TennisClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#TennisClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_TennisClass_delta_new"(s) SELECT t1.o FROM "dbrdf_TennisClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_TennisClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 43
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_MathematicsClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MathematicsClass_delta_old"(s) SELECT t0.s FROM "dbrdf_MathematicsClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MathematicsClass_delta_old" ON "dbrdf_MathematicsClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MathematicsClass_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#MathematicsClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#MathematicsClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MathematicsClass_delta_new"(s) SELECT t1.o FROM "dbrdf_MathematicsClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MathematicsClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MathematicsClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_MathematicsClass_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_MathematicsClass_delta_old";
        INSERT INTO "dbrdf_MathematicsClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MathematicsClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MathematicsClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 44
    ---- DEPENDS ON: 25, 15, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SupportingStaff_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SupportingStaff_delta_old"(s) SELECT t0.s FROM "dbrdf_SupportingStaff" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SupportingStaff_delta_old" ON "dbrdf_SupportingStaff_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SupportingStaff_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#SupportingStaff$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#SupportingStaff$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SupportingStaff_delta_new"(s) SELECT t1.o FROM "dbrdf_SupportingStaff_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SupportingStaff" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SupportingStaff"(s) SELECT DISTINCT t0.s FROM "dbrdf_SupportingStaff_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_SupportingStaff_delta_old";
        INSERT INTO "dbrdf_SupportingStaff_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SupportingStaff_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SupportingStaff_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 45
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_title_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_title_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_title" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_title_delta_old" ON "dbrdf_title_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_title_delta_old" ON "dbrdf_title_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_title_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#title$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#title$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_title_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_title_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_title" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_title"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_title_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_title_delta_old";
        INSERT INTO "dbrdf_title_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_title_delta_new" t0;
        TRUNCATE TABLE "dbrdf_title_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_Modern_ArtsClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Modern_ArtsClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Modern_ArtsClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Modern_ArtsClass_delta_old" ON "dbrdf_Modern_ArtsClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Modern_ArtsClass_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 47
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_telephone_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_telephone_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_telephone0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_telephone_delta_old" ON "dbrdf_telephone_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_telephone_delta_old" ON "dbrdf_telephone_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_telephone_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#telephone$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#telephone$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_telephone_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_telephone_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_telephone0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_telephone0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_telephone_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_telephone_delta_old";
        INSERT INTO "dbrdf_telephone_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_telephone_delta_new" t0;
        TRUNCATE TABLE "dbrdf_telephone_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 49
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_GraduateStudent_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GraduateStudent_delta_old"(s) SELECT t0.s FROM "dbrdf_GraduateStudent0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GraduateStudent_delta_old" ON "dbrdf_GraduateStudent_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GraduateStudent_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#GraduateStudent$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#GraduateStudent$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GraduateStudent_delta_new"(s) SELECT t1.o FROM "dbrdf_GraduateStudent_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_GraduateStudent0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GraduateStudent0"(s) SELECT DISTINCT t0.s FROM "dbrdf_GraduateStudent_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_GraduateStudent_delta_old";
        INSERT INTO "dbrdf_GraduateStudent_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GraduateStudent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GraduateStudent_delta_new";

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_takesCourse_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_takesCourse_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_takesCourse0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_takesCourse_delta_old" ON "dbrdf_takesCourse_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_takesCourse_delta_old" ON "dbrdf_takesCourse_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_takesCourse_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#takesCourse$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#takesCourse$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_takesCourse_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_takesCourse_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_takesCourse0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_takesCourse0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_takesCourse_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_takesCourse_delta_old";
        INSERT INTO "dbrdf_takesCourse_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_takesCourse_delta_new" t0;
        TRUNCATE TABLE "dbrdf_takesCourse_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 51
    ---- DEPENDS ON: 50, 49, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#GraduateCourse>(?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#takesCourse>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#GraduateStudent>(?X) .
    INSERT INTO "dbrdf_GraduateCourse0"(s) SELECT DISTINCT t0.o FROM "dbrdf_takesCourse0" t0, "dbrdf_GraduateStudent0" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_GraduateCourse0" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_GraduateCourse_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GraduateCourse_delta_old"(s) SELECT t0.s FROM "dbrdf_GraduateCourse0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GraduateCourse_delta_old" ON "dbrdf_GraduateCourse_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GraduateCourse_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#GraduateCourse$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#GraduateCourse$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GraduateCourse_delta_new"(s) SELECT t1.o FROM "dbrdf_GraduateCourse_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_GraduateCourse0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GraduateCourse0"(s) SELECT DISTINCT t0.s FROM "dbrdf_GraduateCourse_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_GraduateCourse_delta_old";
        INSERT INTO "dbrdf_GraduateCourse_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GraduateCourse_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GraduateCourse_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 52
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_GeosciencesClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GeosciencesClass_delta_old"(s) SELECT t0.s FROM "dbrdf_GeosciencesClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GeosciencesClass_delta_old" ON "dbrdf_GeosciencesClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GeosciencesClass_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#GeosciencesClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#GeosciencesClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GeosciencesClass_delta_new"(s) SELECT t1.o FROM "dbrdf_GeosciencesClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_GeosciencesClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GeosciencesClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_GeosciencesClass_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_GeosciencesClass_delta_old";
        INSERT INTO "dbrdf_GeosciencesClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GeosciencesClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GeosciencesClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 53
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Marine_ScienceClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Marine_ScienceClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Marine_ScienceClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Marine_ScienceClass_delta_old" ON "dbrdf_Marine_ScienceClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Marine_ScienceClass_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#Marine_ScienceClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Marine_ScienceClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Marine_ScienceClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Marine_ScienceClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Marine_ScienceClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Marine_ScienceClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_Marine_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_Marine_ScienceClass_delta_old";
        INSERT INTO "dbrdf_Marine_ScienceClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Marine_ScienceClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Marine_ScienceClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 55
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_BiologyClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BiologyClass_delta_old"(s) SELECT t0.s FROM "dbrdf_BiologyClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BiologyClass_delta_old" ON "dbrdf_BiologyClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BiologyClass_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#BiologyClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#BiologyClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BiologyClass_delta_new"(s) SELECT t1.o FROM "dbrdf_BiologyClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_BiologyClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BiologyClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_BiologyClass_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_BiologyClass_delta_old";
        INSERT INTO "dbrdf_BiologyClass_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BiologyClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BiologyClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 56
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_age_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_age_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_age" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_age_delta_old" ON "dbrdf_age_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_age_delta_old" ON "dbrdf_age_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_age_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#age$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#age$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_age_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_age_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_age" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_age"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_age_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_age_delta_old";
        INSERT INTO "dbrdf_age_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_age_delta_new" t0;
        TRUNCATE TABLE "dbrdf_age_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 57
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_publicationAuthor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_publicationAuthor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_publicationAuthor0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_publicationAuthor_delta_old" ON "dbrdf_publicationAuthor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_publicationAuthor_delta_old" ON "dbrdf_publicationAuthor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_publicationAuthor_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#publicationAuthor$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#publicationAuthor$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_publicationAuthor_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_publicationAuthor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_publicationAuthor0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_publicationAuthor0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_publicationAuthor_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_publicationAuthor_delta_old";
        INSERT INTO "dbrdf_publicationAuthor_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_publicationAuthor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_publicationAuthor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 58
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 59
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lastName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lastName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lastName_delta_old" ON "dbrdf_lastName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lastName_delta_old" ON "dbrdf_lastName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lastName_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#lastName$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#lastName$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lastName_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lastName_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lastName" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lastName"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lastName_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_lastName_delta_old";
        INSERT INTO "dbrdf_lastName_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lastName_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lastName_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 60
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_subOrganizationOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_subOrganizationOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_subOrganizationOf0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_subOrganizationOf_delta_old" ON "dbrdf_subOrganizationOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subOrganizationOf_delta_old" ON "dbrdf_subOrganizationOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subOrganizationOf_old"(s integer, o integer) ON COMMIT DROP;
    CREATE INDEX "IDX_0_dbrdf_subOrganizationOf_old" ON "dbrdf_subOrganizationOf_old"(s, o); CREATE INDEX "IDX_1_dbrdf_subOrganizationOf_old" ON "dbrdf_subOrganizationOf_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_subOrganizationOf_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#subOrganizationOf$delta_new>(?X,?Z) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#subOrganizationOf$delta_old>(?X,?Y), <http://semantics.crl.ibm.com/univ-bench-dl.owl#subOrganizationOf>(?Y,?Z) .
        INSERT INTO "dbrdf_subOrganizationOf_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_subOrganizationOf_delta_old" t0, "dbrdf_subOrganizationOf0" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_subOrganizationOf0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#subOrganizationOf$delta_new>(?X,?Z) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#subOrganizationOf>(?X,?Y), <http://semantics.crl.ibm.com/univ-bench-dl.owl#subOrganizationOf$delta_old>(?Y,?Z) .
        INSERT INTO "dbrdf_subOrganizationOf_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_subOrganizationOf0" t0, "dbrdf_subOrganizationOf_delta_old" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_subOrganizationOf0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_subOrganizationOf_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_subOrganizationOf_delta_old" t0;
        INSERT INTO "dbrdf_subOrganizationOf0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_subOrganizationOf_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_subOrganizationOf_delta_old";
        INSERT INTO "dbrdf_subOrganizationOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_subOrganizationOf_delta_new" t0;
        TRUNCATE TABLE "dbrdf_subOrganizationOf_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 61
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 62
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 63
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_PostDoc_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PostDoc_delta_old"(s) SELECT t0.s FROM "dbrdf_PostDoc" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PostDoc_delta_old" ON "dbrdf_PostDoc_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PostDoc_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#PostDoc$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#PostDoc$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PostDoc_delta_new"(s) SELECT t1.o FROM "dbrdf_PostDoc_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PostDoc" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PostDoc"(s) SELECT DISTINCT t0.s FROM "dbrdf_PostDoc_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_PostDoc_delta_old";
        INSERT INTO "dbrdf_PostDoc_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PostDoc_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PostDoc_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 64
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orgPublication_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orgPublication_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_orgPublication" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orgPublication_delta_old" ON "dbrdf_orgPublication_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orgPublication_delta_old" ON "dbrdf_orgPublication_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orgPublication_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#orgPublication$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#orgPublication$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_orgPublication_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_orgPublication_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_orgPublication" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_orgPublication"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orgPublication_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_orgPublication_delta_old";
        INSERT INTO "dbrdf_orgPublication_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orgPublication_delta_new" t0;
        TRUNCATE TABLE "dbrdf_orgPublication_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 65
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 66
    ---- DEPENDS ON: 65, 20, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 67
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 68
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasDoctoralDegreeFrom_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasDoctoralDegreeFrom_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasDoctoralDegreeFrom" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasDoctoralDegreeFrom_delta_old" ON "dbrdf_hasDoctoralDegreeFrom_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasDoctoralDegreeFrom_delta_old" ON "dbrdf_hasDoctoralDegreeFrom_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasDoctoralDegreeFrom_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#hasDoctoralDegreeFrom$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasDoctoralDegreeFrom$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_hasDoctoralDegreeFrom_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_hasDoctoralDegreeFrom_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_hasDoctoralDegreeFrom" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_hasDoctoralDegreeFrom"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasDoctoralDegreeFrom_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_hasDoctoralDegreeFrom_delta_old";
        INSERT INTO "dbrdf_hasDoctoralDegreeFrom_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasDoctoralDegreeFrom_delta_new" t0;
        TRUNCATE TABLE "dbrdf_hasDoctoralDegreeFrom_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 69
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BaseballClass_delta_old"(s) SELECT t0.s FROM "dbrdf_BaseballClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BaseballClass_delta_old" ON "dbrdf_BaseballClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballClass_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#BaseballClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#BaseballClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BaseballClass_delta_new"(s) SELECT t1.o FROM "dbrdf_BaseballClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_BaseballClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_BaseballClass"(s) SELECT DISTINCT t0.s 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 70
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AssociateProfessor_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AssociateProfessor_delta_old"(s) SELECT t0.s FROM "dbrdf_AssociateProfessor0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AssociateProfessor_delta_old" ON "dbrdf_AssociateProfessor_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AssociateProfessor_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#AssociateProfessor$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#AssociateProfessor$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_AssociateProfessor_delta_new"(s) SELECT t1.o FROM "dbrdf_AssociateProfessor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_AssociateProfessor0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AssociateProfessor0"(s) SELECT DISTINCT t0.s FROM "dbrdf_AssociateProfessor_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_AssociateProfessor_delta_old";
        INSERT INTO "dbrdf_AssociateProfessor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_AssociateProfessor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_AssociateProfessor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 71
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasMajor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasMajor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasMajor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasMajor_delta_old" ON "dbrdf_hasMajor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasMajor_delta_old" ON "dbrdf_hasMajor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasMajor_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#hasMajor$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasMajor$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_hasMajor_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_hasMajor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_hasMajor" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 72
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_NonScienceStudent_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_NonScienceStudent_delta_old"(s) SELECT t0.s FROM "dbrdf_NonScienceStudent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_NonScienceStudent_delta_old" ON "dbrdf_NonScienceStudent_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_NonScienceStudent_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#NonScienceStudent$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#NonScienceStudent$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_NonScienceStudent_delta_new"(s) SELECT t1.o FROM "dbrdf_NonScienceStudent_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_NonScienceStudent" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 73
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 74
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isCrazyAbout_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isCrazyAbout_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isCrazyAbout" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isCrazyAbout_delta_old" ON "dbrdf_isCrazyAbout_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isCrazyAbout_delta_old" ON "dbrdf_isCrazyAbout_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isCrazyAbout_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#isCrazyAbout$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isCrazyAbout$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_isCrazyAbout_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_isCrazyAbout_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_isCrazyAbout" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 75
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 76
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SwimmingClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SwimmingClass_delta_old"(s) SELECT t0.s FROM "dbrdf_SwimmingClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SwimmingClass_delta_old" ON "dbrdf_SwimmingClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SwimmingClass_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#SwimmingClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#SwimmingClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SwimmingClass_delta_new"(s) SELECT t1.o FROM "dbrdf_SwimmingClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SwimmingClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 77
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Institute_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Institute_delta_old"(s) SELECT t0.s FROM "dbrdf_Institute" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Institute_delta_old" ON "dbrdf_Institute_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Institute_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#Institute$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Institute$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Institute_delta_new"(s) SELECT t1.o FROM "dbrdf_Institute_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Institute" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Institute"(s) SELECT DISTINCT t0.s FROM "dbrdf_Institute_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_Institute_delta_old";
        INSERT INTO "dbrdf_Institute_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Institute_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Institute_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 78
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 79
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 80
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 81
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasSameHomeTownWith_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasSameHomeTownWith_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasSameHomeTownWith" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasSameHomeTownWith_delta_old" ON "dbrdf_hasSameHomeTownWith_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasSameHomeTownWith_delta_old" ON "dbrdf_hasSameHomeTownWith_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasSameHomeTownWith_old"(s integer, o integer) ON COMMIT DROP;
    CREATE INDEX "IDX_0_dbrdf_hasSameHomeTownWith_old" ON "dbrdf_hasSameHomeTownWith_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasSameHomeTownWith_old" ON "dbrdf_hasSameHomeTownWith_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasSameHomeTownWith_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#hasSameHomeTownWith$delta_new>(?X,?Z) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasSameHomeTownWith$delta_old>(?X,?Y), <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasSameHomeTownWith>(?Y,?Z) .
        INSERT INTO "dbrdf_hasSameHomeTownWith_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_hasSameHomeTownWith_delta_old" t0, "dbrdf_hasSameHomeTownWith" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_hasSameHomeTownWith" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasSameHomeTownWith$delta_new>(?X,?Z) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasSameHomeTownWith>(?X,?Y), <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasSameHomeTownWith$delta_old>(?Y,?Z) .
        INSERT INTO "dbrdf_hasSameHomeTownWith_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_hasSameHomeTownWith" t0, "dbrdf_hasSameHomeTownWith_delta_old" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_hasSameHomeTownWith" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasSameHomeTownWith$delta_new>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasSameHomeTownWith$delta_old>(?Y,?X) .
        INSERT INTO "dbrdf_hasSameHomeTownWith_delta_new"(s, o) SELECT t0.o, t0.s FROM "dbrdf_hasSameHomeTownWith_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_hasSameHomeTownWith" ex WHERE ex.s = t0.o AND ex.o = t0.s);


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_hasSameHomeTownWith_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasSameHomeTownWith_delta_old" t0;
        INSERT INTO "dbrdf_hasSameHomeTownWith"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasSameHomeTownWith_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_hasSameHomeTownWith_delta_old";
        INSERT INTO "dbrdf_hasSameHomeTownWith_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hasSameHomeTownWith_delta_new" t0;
        TRUNCATE TABLE "dbrdf_hasSameHomeTownWith_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 82
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_AstronomyClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_AstronomyClass_delta_old"(s) SELECT t0.s FROM "dbrdf_AstronomyClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_AstronomyClass_delta_old" ON "dbrdf_AstronomyClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_AstronomyClass_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#AstronomyClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#AstronomyClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_AstronomyClass_delta_new"(s) SELECT t1.o FROM "dbrdf_AstronomyClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_AstronomyClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_AstronomyClass"(s) SELECT DISTINCT t0.s FROM "dbrdf_AstronomyClass_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_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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 83
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 84
    ---- DEPENDS ON: 83, 80, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 85
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_enrollIn_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_enrollIn_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_enrollIn" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_enrollIn_delta_old" ON "dbrdf_enrollIn_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_enrollIn_delta_old" ON "dbrdf_enrollIn_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_enrollIn_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#enrollIn$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#enrollIn$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_enrollIn_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_enrollIn_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_enrollIn" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_enrollIn"(s, o) SELECT DISTINCT t0.s, 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 86
    ---- DEPENDS ON: 85, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Department_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Department_delta_old"(s) SELECT t0.s FROM "dbrdf_Department0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Department_delta_old" ON "dbrdf_Department_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Department_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#Department$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Department$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Department_delta_new"(s) SELECT t1.o FROM "dbrdf_Department_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Department0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Department0"(s) SELECT DISTINCT t0.s 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 87
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isAffiliateOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isAffiliateOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isAffiliateOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isAffiliateOf_delta_old" ON "dbrdf_isAffiliateOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isAffiliateOf_delta_old" ON "dbrdf_isAffiliateOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isAffiliateOf_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#isAffiliateOf$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isAffiliateOf$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_isAffiliateOf_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_isAffiliateOf_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_isAffiliateOf" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_isAffiliateOf"(s, o) SELECT DISTINCT t0.s, 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 88
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isAffiliatedOrganizationOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isAffiliatedOrganizationOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isAffiliatedOrganizationOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isAffiliatedOrganizationOf_delta_old" ON "dbrdf_isAffiliatedOrganizationOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isAffiliatedOrganizationOf_delta_old" ON "dbrdf_isAffiliatedOrganizationOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isAffiliatedOrganizationOf_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#isAffiliatedOrganizationOf$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isAffiliatedOrganizationOf$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_isAffiliatedOrganizationOf_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_isAffiliatedOrganizationOf_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_isAffiliatedOrganizationOf" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_isAffiliatedOrganizationOf"(s, o) SELECT DISTINCT t0.s, 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 89
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasMasterDegreeFrom_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasMasterDegreeFrom_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasMasterDegreeFrom" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasMasterDegreeFrom_delta_old" ON "dbrdf_hasMasterDegreeFrom_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasMasterDegreeFrom_delta_old" ON "dbrdf_hasMasterDegreeFrom_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasMasterDegreeFrom_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#hasMasterDegreeFrom$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasMasterDegreeFrom$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_hasMasterDegreeFrom_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_hasMasterDegreeFrom_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_hasMasterDegreeFrom" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_hasMasterDegreeFrom"(s, o) SELECT DISTINCT t0.s, 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 90
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_teachingAssistantOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_teachingAssistantOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_teachingAssistantOf0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_teachingAssistantOf_delta_old" ON "dbrdf_teachingAssistantOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_teachingAssistantOf_delta_old" ON "dbrdf_teachingAssistantOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_teachingAssistantOf_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#teachingAssistantOf$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#teachingAssistantOf$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_teachingAssistantOf_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_teachingAssistantOf_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_teachingAssistantOf0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_teachingAssistantOf0"(s, o) SELECT DISTINCT t0.s, 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 91
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 92
    ---- DEPENDS ON: 91, 62, 39, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 93
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 94
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 95
    ---- DEPENDS ON: 94, 93, 73, 67, 61, 53, 38, 23, 12, 5, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 96
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_BasketBallClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BasketBallClass_delta_old"(s) SELECT t0.s FROM "dbrdf_BasketBallClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BasketBallClass_delta_old" ON "dbrdf_BasketBallClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BasketBallClass_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#BasketBallClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#BasketBallClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BasketBallClass_delta_new"(s) SELECT t1.o FROM "dbrdf_BasketBallClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_BasketBallClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 97
    ---- DEPENDS ON: 96, 76, 69, 42, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sports_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Sports_delta_old"(s) SELECT t0.s FROM "dbrdf_Sports" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Sports_delta_old" ON "dbrdf_Sports_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Sports_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#Sports$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Sports$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Sports_delta_new"(s) SELECT t1.o FROM "dbrdf_Sports_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Sports" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 98
    ---- DEPENDS ON: 97, 8, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 99
    ---- DEPENDS ON: 74, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#like>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isCrazyAbout>(?X,?Y) .
    INSERT INTO "dbrdf_like"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isCrazyAbout" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_like" ex WHERE ex.s = t0.s AND ex.o = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_love_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_love_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_love" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_love_delta_old" ON "dbrdf_love_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_love_delta_old" ON "dbrdf_love_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_love_delta_new"(s integer, o integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_like_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_like_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_like" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_like_delta_old" ON "dbrdf_like_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_like_delta_old" ON "dbrdf_like_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_like_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#love$delta_new>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#like$delta_old>(?X,?Y) .
        INSERT INTO "dbrdf_love_delta_new"(s, o) SELECT t0.s, t0.o FROM "dbrdf_like_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_love" ex WHERE ex.s = t0.s AND ex.o = t0.o);


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


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#like$delta_new>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#love$delta_old>(?X,?Y) .
        INSERT INTO "dbrdf_like_delta_new"(s, o) SELECT t0.s, t0.o FROM "dbrdf_love_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_like" ex WHERE ex.s = t0.s AND ex.o = t0.o);


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_love"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_love_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_love_delta_old";
        INSERT INTO "dbrdf_love_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_love_delta_new" t0;
        TRUNCATE TABLE "dbrdf_love_delta_new";

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 100
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Materials_ScienceClass_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Materials_ScienceClass_delta_old"(s) SELECT t0.s FROM "dbrdf_Materials_ScienceClass" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Materials_ScienceClass_delta_old" ON "dbrdf_Materials_ScienceClass_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Materials_ScienceClass_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#Materials_ScienceClass$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Materials_ScienceClass$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Materials_ScienceClass_delta_new"(s) SELECT t1.o FROM "dbrdf_Materials_ScienceClass_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Materials_ScienceClass" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Materials_ScienceClass"(s) SELECT DISTINCT t0.s 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 101
    ---- DEPENDS ON: 100, 82, 55, 54, 52, 43, 41, 28, 17, 10, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Science_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Science_delta_old"(s) SELECT t0.s FROM "dbrdf_Science" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Science_delta_old" ON "dbrdf_Science_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Science_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#Science$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Science$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Science_delta_new"(s) SELECT t1.o FROM "dbrdf_Science_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Science" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 102
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isAdvisedBy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isAdvisedBy_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isAdvisedBy" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isAdvisedBy_delta_old" ON "dbrdf_isAdvisedBy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isAdvisedBy_delta_old" ON "dbrdf_isAdvisedBy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isAdvisedBy_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#isAdvisedBy$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isAdvisedBy$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_isAdvisedBy_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_isAdvisedBy_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_isAdvisedBy" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_isAdvisedBy"(s, o) SELECT DISTINCT t0.s, 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 103
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstName_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstName" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstName_delta_old" ON "dbrdf_firstName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstName_delta_old" ON "dbrdf_firstName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstName_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#firstName$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#firstName$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_firstName_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_firstName_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstName" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_firstName"(s, o) SELECT DISTINCT t0.s, 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 104
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 105
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 106
    ---- DEPENDS ON: 105, 78, 75, 46, 40, 33, 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 "dbrdf_FineArts"(s) SELECT t0.s FROM "dbrdf_Medieval_ArtsClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_FineArts" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

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

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 107
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 108
    ---- DEPENDS ON: 107, 79, 58, 30, 27, 22, 18, 16, 11, 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 "dbrdf_Engineering"(s) SELECT t0.s FROM "dbrdf_Chemical_EngineeringClass" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Engineering" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

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

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 109
    ---- DEPENDS ON: 71, 101, 108, 106, 95, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 110
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Man_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Man_delta_old"(s) SELECT t0.s FROM "dbrdf_Man" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Man_delta_old" ON "dbrdf_Man_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Man_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#Man$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Man$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Man_delta_new"(s) SELECT t1.o FROM "dbrdf_Man_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Man" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Man"(s) SELECT DISTINCT t0.s 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 111
    ---- DEPENDS ON: 85, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#isStudentOf>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#enrollIn>(?X,?Y) .
    INSERT INTO "dbrdf_isStudentOf"(s, o) SELECT t0.s, t0.o FROM "dbrdf_enrollIn" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_isStudentOf" ex WHERE ex.s = t0.s AND ex.o = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isStudentOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isStudentOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isStudentOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isStudentOf_delta_old" ON "dbrdf_isStudentOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isStudentOf_delta_old" ON "dbrdf_isStudentOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isStudentOf_delta_new"(s integer, o integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasStudent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasStudent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasStudent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasStudent_delta_old" ON "dbrdf_hasStudent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasStudent_delta_old" ON "dbrdf_hasStudent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasStudent_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#isStudentOf$delta_new>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasStudent$delta_old>(?Y,?X) .
        INSERT INTO "dbrdf_isStudentOf_delta_new"(s, o) SELECT t0.o, t0.s FROM "dbrdf_hasStudent_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_isStudentOf" ex WHERE ex.s = t0.o AND ex.o = t0.s);


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


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasStudent$delta_new>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isStudentOf$delta_old>(?Y,?X) .
        INSERT INTO "dbrdf_hasStudent_delta_new"(s, o) SELECT t0.o, t0.s FROM "dbrdf_isStudentOf_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_hasStudent" ex WHERE ex.s = t0.o AND ex.o = t0.s);


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


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


        -- Propagate $delta_new

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

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 112
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_WomanCollege_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_WomanCollege_delta_old"(s) SELECT t0.s FROM "dbrdf_WomanCollege" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_WomanCollege_delta_old" ON "dbrdf_WomanCollege_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_WomanCollege_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#WomanCollege$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#WomanCollege$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_WomanCollege_delta_new"(s) SELECT t1.o FROM "dbrdf_WomanCollege_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_WomanCollege" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_WomanCollege"(s) SELECT DISTINCT t0.s 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 113
    ---- DEPENDS ON: 112, 111, 110, 104, 103, 72, 71, 101, 59, 36, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] owl:Nothing(<int$false>) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Man>(?X2), <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasStudent>(?X,?X2), <http://semantics.crl.ibm.com/univ-bench-dl.owl#WomanCollege>(?X) .
    INSERT INTO "dbrdf_Nothing"(s) SELECT DISTINCT 26425 FROM "dbrdf_Man" t0, "dbrdf_hasStudent" t1, "dbrdf_WomanCollege" t2 WHERE t0.s = t1.o AND t1.s = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Nothing" ex WHERE ex.s = 26425);
    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#firstName>(?X,?X1) .
    INSERT INTO "dbrdf_Nothing"(s) SELECT DISTINCT 26425 FROM "dbrdf_notInValueSpace" t0, "dbrdf_firstName" t1 WHERE t0.s = t1.o AND t0.o = 26426 AND NOT EXISTS (SELECT 1 FROM "dbrdf_Nothing" ex WHERE ex.s = 26425);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] owl:Nothing(<int$false>) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasMajor>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#Science>(?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#NonScienceStudent>(?X) .
    INSERT INTO "dbrdf_Nothing"(s) SELECT DISTINCT 26425 FROM "dbrdf_hasMajor" t0, "dbrdf_Science" t1, "dbrdf_NonScienceStudent" t2 WHERE t0.o = t1.s AND t0.s = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Nothing" ex WHERE ex.s = 26425);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

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

    -- [Rule] owl:Nothing(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Man>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#Woman>(?X) .
    INSERT INTO "dbrdf_Nothing"(s) SELECT DISTINCT t0.s FROM "dbrdf_Man" t0, "dbrdf_Woman" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Nothing" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 114
    ---- DEPENDS ON: 112, 111, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#UndergraduateStudent>(?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasStudent>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#WomanCollege>(?X) .
    INSERT INTO "dbrdf_UndergraduateStudent0"(s) SELECT DISTINCT t0.o FROM "dbrdf_hasStudent" t0, "dbrdf_WomanCollege" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_UndergraduateStudent0" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_UndergraduateStudent_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_UndergraduateStudent_delta_old"(s) SELECT t0.s FROM "dbrdf_UndergraduateStudent0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_UndergraduateStudent_delta_old" ON "dbrdf_UndergraduateStudent_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_UndergraduateStudent_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#UndergraduateStudent$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#UndergraduateStudent$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_UndergraduateStudent_delta_new"(s) SELECT t1.o FROM "dbrdf_UndergraduateStudent_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_UndergraduateStudent0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 115
    ---- DEPENDS ON: 112, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_College_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_College_delta_old"(s) SELECT t0.s FROM "dbrdf_College" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_College_delta_old" ON "dbrdf_College_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_College_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#College$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#College$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_College_delta_new"(s) SELECT t1.o FROM "dbrdf_College_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_College" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_College"(s) SELECT DISTINCT t0.s 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 116
    ---- DEPENDS ON: 89, 68, 21, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasDegreeFrom>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasDoctoralDegreeFrom>(?X,?Y) .
    INSERT INTO "dbrdf_hasDegreeFrom"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasDoctoralDegreeFrom" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_hasDegreeFrom" ex WHERE ex.s = t0.s AND ex.o = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasDegreeFrom>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasMasterDegreeFrom>(?X,?Y) .
    INSERT INTO "dbrdf_hasDegreeFrom"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasMasterDegreeFrom" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_hasDegreeFrom" ex WHERE ex.s = t0.s AND ex.o = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasDegreeFrom>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasUndergraduateDegreeFrom>(?X,?Y) .
    INSERT INTO "dbrdf_hasDegreeFrom"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasUndergraduateDegreeFrom" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_hasDegreeFrom" ex WHERE ex.s = t0.s AND ex.o = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasAlumnus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasAlumnus_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasAlumnus" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasAlumnus_delta_old" ON "dbrdf_hasAlumnus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasAlumnus_delta_old" ON "dbrdf_hasAlumnus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasAlumnus_delta_new"(s integer, o integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasDegreeFrom_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasDegreeFrom_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasDegreeFrom" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasDegreeFrom_delta_old" ON "dbrdf_hasDegreeFrom_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasDegreeFrom_delta_old" ON "dbrdf_hasDegreeFrom_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasDegreeFrom_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#hasAlumnus$delta_new>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasDegreeFrom$delta_old>(?Y,?X) .
        INSERT INTO "dbrdf_hasAlumnus_delta_new"(s, o) SELECT t0.o, t0.s FROM "dbrdf_hasDegreeFrom_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_hasAlumnus" ex WHERE ex.s = t0.o AND ex.o = t0.s);


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


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasDegreeFrom$delta_new>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasAlumnus$delta_old>(?Y,?X) .
        INSERT INTO "dbrdf_hasDegreeFrom_delta_new"(s, o) SELECT t0.o, t0.s FROM "dbrdf_hasAlumnus_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_hasDegreeFrom" ex WHERE ex.s = t0.o AND ex.o = t0.s);


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


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_hasAlumnus"(s, o) SELECT DISTINCT t0.s, 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_hasDegreeFrom"(s, o) SELECT DISTINCT t0.s, 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 117
    ---- DEPENDS ON: 116, 89, 68, 21, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_University_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_University_delta_old"(s) SELECT t0.s FROM "dbrdf_University0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_University_delta_old" ON "dbrdf_University_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_University_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#University$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#University$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_University_delta_new"(s) SELECT t1.o FROM "dbrdf_University_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_University0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_University0"(s) SELECT DISTINCT t0.s 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 118
    ---- DEPENDS ON: 0, 115
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#Dean>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isHeadOf>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#College>(?X1) .
    INSERT INTO "dbrdf_Dean"(s) SELECT DISTINCT t0.s FROM "dbrdf_isHeadOf" t0, "dbrdf_College" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Dean" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Dean_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Dean_delta_old"(s) SELECT t0.s FROM "dbrdf_Dean" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Dean_delta_old" ON "dbrdf_Dean_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Dean_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#Dean$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Dean$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Dean_delta_new"(s) SELECT t1.o FROM "dbrdf_Dean_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Dean" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Dean"(s) SELECT DISTINCT t0.s 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 119
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#worksFor>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isHeadOf>(?X,?Y) .
    INSERT INTO "dbrdf_worksFor0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isHeadOf" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_worksFor0" ex WHERE ex.s = t0.s AND ex.o = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_worksFor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_worksFor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_worksFor0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_worksFor_delta_old" ON "dbrdf_worksFor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_worksFor_delta_old" ON "dbrdf_worksFor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_worksFor_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#worksFor$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#worksFor$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_worksFor_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_worksFor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_worksFor0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 120
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_listedCourse_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_listedCourse_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_listedCourse" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_listedCourse_delta_old" ON "dbrdf_listedCourse_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_listedCourse_delta_old" ON "dbrdf_listedCourse_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_listedCourse_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#listedCourse$delta_new>(?Y,?X1) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#listedCourse$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_listedCourse_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_listedCourse_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_listedCourse" ex WHERE ex.s = t1.o AND ex.o = t0.o);


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


        -- Propagate $delta_new

        INSERT INTO "dbrdf_listedCourse"(s, o) SELECT DISTINCT t0.s, 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";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 121
    ---- DEPENDS ON: 120, 0
    ----------------------------------------

    -- Nonrecursive rules

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 122
    ---- DEPENDS ON: 120, 90, 0, 51
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Course_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Course_delta_old"(s) SELECT t0.s FROM "dbrdf_Course0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Course_delta_old" ON "dbrdf_Course_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Course_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#Course$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Course$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Course_delta_new"(s) SELECT t1.o FROM "dbrdf_Course_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Course0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 123
    ---- DEPENDS ON: 122, 66, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 124
    ---- DEPENDS ON: 119, 111, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#isMemberOf>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isStudentOf>(?X,?Y) .
    INSERT INTO "dbrdf_isMemberOf"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isStudentOf" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_isMemberOf" ex WHERE ex.s = t0.s AND ex.o = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#isMemberOf>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#worksFor>(?X,?Y) .
    INSERT INTO "dbrdf_isMemberOf"(s, o) SELECT t0.s, t0.o FROM "dbrdf_worksFor0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_isMemberOf" ex WHERE ex.s = t0.s AND ex.o = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasMember>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasStudent>(?X,?Y) .
    INSERT INTO "dbrdf_hasMember"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasStudent" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_hasMember" ex WHERE ex.s = t0.s AND ex.o = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isMemberOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isMemberOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isMemberOf" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isMemberOf_delta_old" ON "dbrdf_isMemberOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isMemberOf_delta_old" ON "dbrdf_isMemberOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isMemberOf_delta_new"(s integer, o integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hasMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hasMember" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hasMember_delta_old" ON "dbrdf_hasMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hasMember_delta_old" ON "dbrdf_hasMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hasMember_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#isMemberOf$delta_new>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasMember$delta_old>(?Y,?X) .
        INSERT INTO "dbrdf_isMemberOf_delta_new"(s, o) SELECT t0.o, t0.s FROM "dbrdf_hasMember_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_isMemberOf" ex WHERE ex.s = t0.o AND ex.o = t0.s);


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


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasMember$delta_new>(?X,?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#isMemberOf$delta_old>(?Y,?X) .
        INSERT INTO "dbrdf_hasMember_delta_new"(s, o) SELECT t0.o, t0.s FROM "dbrdf_isMemberOf_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_hasMember" ex WHERE ex.s = t0.o AND ex.o = t0.s);


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


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


        -- Propagate $delta_new

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

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 125
    ---- DEPENDS ON: 124, 111, 88, 87, 86, 77, 64, 117, 60, 115, 34, 14, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Organization_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Organization_delta_old"(s) SELECT t0.s FROM "dbrdf_Organization" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Organization_delta_old" ON "dbrdf_Organization_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Organization_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#Organization$delta_new>(?Y) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Organization$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Organization_delta_new"(s) SELECT t1.o FROM "dbrdf_Organization_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Organization" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 126
    ---- DEPENDS ON: 124, 0, 116, 119, 125, 111, 110, 103, 118, 102, 99, 96, 90, 89, 87, 81, 114, 86, 76, 74, 122, 72, 71, 101, 70, 69, 68, 63, 59, 57, 56, 50, 48, 45, 44, 42, 36, 35, 32, 31, 29, 26, 24, 21, 19, 97, 14, 9
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SportsLover_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SportsLover_delta_old"(s) SELECT t0.s FROM "dbrdf_SportsLover" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SportsLover_delta_old" ON "dbrdf_SportsLover_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SportsLover_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Director_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Director_delta_old"(s) SELECT t0.s FROM "dbrdf_Director" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Director_delta_old" ON "dbrdf_Director_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Director_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SportsFan_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SportsFan_delta_old"(s) SELECT t0.s FROM "dbrdf_SportsFan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SportsFan_delta_old" ON "dbrdf_SportsFan_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SportsFan_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballFan_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BaseballFan_delta_old"(s) SELECT t0.s FROM "dbrdf_BaseballFan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BaseballFan_delta_old" ON "dbrdf_BaseballFan_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballFan_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TennisFan_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TennisFan_delta_old"(s) SELECT t0.s FROM "dbrdf_TennisFan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TennisFan_delta_old" ON "dbrdf_TennisFan_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TennisFan_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ScienceStudent_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ScienceStudent_delta_old"(s) SELECT t0.s FROM "dbrdf_ScienceStudent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ScienceStudent_delta_old" ON "dbrdf_ScienceStudent_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ScienceStudent_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Student_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Student_delta_old"(s) SELECT t0.s FROM "dbrdf_Student" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Student_delta_old" ON "dbrdf_Student_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Student_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballLover_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BaseballLover_delta_old"(s) SELECT t0.s FROM "dbrdf_BaseballLover" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BaseballLover_delta_old" ON "dbrdf_BaseballLover_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballLover_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SwimmingFan_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SwimmingFan_delta_old"(s) SELECT t0.s FROM "dbrdf_SwimmingFan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SwimmingFan_delta_old" ON "dbrdf_SwimmingFan_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SwimmingFan_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TeachingAssistant_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_TeachingAssistant_delta_old"(s) SELECT t0.s FROM "dbrdf_TeachingAssistant0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_TeachingAssistant_delta_old" ON "dbrdf_TeachingAssistant_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_TeachingAssistant_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BasketBallFan_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BasketBallFan_delta_old"(s) SELECT t0.s FROM "dbrdf_BasketBallFan" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BasketBallFan_delta_old" ON "dbrdf_BasketBallFan_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BasketBallFan_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SwimmingLover_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SwimmingLover_delta_old"(s) SELECT t0.s FROM "dbrdf_SwimmingLover" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SwimmingLover_delta_old" ON "dbrdf_SwimmingLover_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SwimmingLover_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Faculty_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Faculty_delta_old"(s) SELECT t0.s FROM "dbrdf_Faculty" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Faculty_delta_old" ON "dbrdf_Faculty_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Faculty_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Professor_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Professor_delta_old"(s) SELECT t0.s FROM "dbrdf_Professor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Professor_delta_old" ON "dbrdf_Professor_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Professor_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Chair_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Chair_delta_old"(s) SELECT t0.s FROM "dbrdf_Chair" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Chair_delta_old" ON "dbrdf_Chair_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Chair_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PeopleWithHobby_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PeopleWithHobby_delta_old"(s) SELECT t0.s FROM "dbrdf_PeopleWithHobby" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PeopleWithHobby_delta_old" ON "dbrdf_PeopleWithHobby_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PeopleWithHobby_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BasketBallLover_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BasketBallLover_delta_old"(s) SELECT t0.s FROM "dbrdf_BasketBallLover" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BasketBallLover_delta_old" ON "dbrdf_BasketBallLover_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BasketBallLover_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Employee_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Employee_delta_old"(s) SELECT t0.s FROM "dbrdf_Employee" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Employee_delta_old" ON "dbrdf_Employee_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Employee_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Person_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Person_delta_old"(s) SELECT t0.s FROM "dbrdf_Person" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Person_delta_old" ON "dbrdf_Person_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Person_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#SportsLover$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#like>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#Sports>(?X1) .
        INSERT INTO "dbrdf_SportsLover_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_like" t1, "dbrdf_Sports" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SportsLover" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Director$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#isHeadOf>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#Program>(?X1) .
        INSERT INTO "dbrdf_Director_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_isHeadOf" t1, "dbrdf_Program" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Director" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#SportsFan$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#isCrazyAbout>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#Sports>(?X1) .
        INSERT INTO "dbrdf_SportsFan_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_isCrazyAbout" t1, "dbrdf_Sports" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SportsFan" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#BaseballFan$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#isCrazyAbout>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#BaseballClass>(?X1) .
        INSERT INTO "dbrdf_BaseballFan_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_isCrazyAbout" t1, "dbrdf_BaseballClass" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_BaseballFan" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#TennisFan$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#isCrazyAbout>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#TennisClass>(?X1) .
        INSERT INTO "dbrdf_TennisFan_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_isCrazyAbout" t1, "dbrdf_TennisClass" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_TennisFan" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ScienceStudent$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Student$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#hasMajor>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#Science>(?X1) .
        INSERT INTO "dbrdf_ScienceStudent_delta_new"(s) SELECT t0.s FROM "dbrdf_Student_delta_old" t0, "dbrdf_hasMajor" t1, "dbrdf_Science" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ScienceStudent" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Student$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#ScienceStudent$delta_old>(?X) .
        INSERT INTO "dbrdf_Student_delta_new"(s) SELECT t0.s FROM "dbrdf_ScienceStudent_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Student" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Student$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#isStudentOf>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#Organization>(?X1) .
        INSERT INTO "dbrdf_Student_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_isStudentOf" t1, "dbrdf_Organization" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Student" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#BaseballLover$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#like>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#BaseballClass>(?X1) .
        INSERT INTO "dbrdf_BaseballLover_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_like" t1, "dbrdf_BaseballClass" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_BaseballLover" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#SwimmingFan$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#isCrazyAbout>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#SwimmingClass>(?X1) .
        INSERT INTO "dbrdf_SwimmingFan_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_isCrazyAbout" t1, "dbrdf_SwimmingClass" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SwimmingFan" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#TeachingAssistant$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#teachingAssistantOf>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#Course>(?X1) .
        INSERT INTO "dbrdf_TeachingAssistant_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_teachingAssistantOf0" t1, "dbrdf_Course0" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_TeachingAssistant0" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#BasketBallFan$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#isCrazyAbout>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#BasketBallClass>(?X1) .
        INSERT INTO "dbrdf_BasketBallFan_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_isCrazyAbout" t1, "dbrdf_BasketBallClass" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_BasketBallFan" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#SwimmingLover$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#like>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#SwimmingClass>(?X1) .
        INSERT INTO "dbrdf_SwimmingLover_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_like" t1, "dbrdf_SwimmingClass" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SwimmingLover" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Faculty$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Professor$delta_old>(?X) .
        INSERT INTO "dbrdf_Faculty_delta_new"(s) SELECT t0.s FROM "dbrdf_Professor_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Faculty" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Professor$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Chair$delta_old>(?X) .
        INSERT INTO "dbrdf_Professor_delta_new"(s) SELECT t0.s FROM "dbrdf_Chair_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Professor" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Chair$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#isHeadOf>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#Department>(?X1) .
        INSERT INTO "dbrdf_Chair_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_isHeadOf" t1, "dbrdf_Department0" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Chair" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#PeopleWithHobby$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#like>(?X,?X1) .
        INSERT INTO "dbrdf_PeopleWithHobby_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_like" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PeopleWithHobby" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#BasketBallLover$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#like>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#BasketBallClass>(?X1) .
        INSERT INTO "dbrdf_BasketBallLover_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_like" t1, "dbrdf_BasketBallClass" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_BasketBallLover" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Employee$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_old>(?X), <http://semantics.crl.ibm.com/univ-bench-dl.owl#worksFor>(?X,?X1), <http://semantics.crl.ibm.com/univ-bench-dl.owl#Organization>(?X1) .
        INSERT INTO "dbrdf_Employee_delta_new"(s) SELECT t0.s FROM "dbrdf_Person_delta_old" t0, "dbrdf_worksFor0" t1, "dbrdf_Organization" t2 WHERE t0.s = t1.s AND t1.o = t2.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Employee" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Employee$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Faculty$delta_old>(?X) .
        INSERT INTO "dbrdf_Employee_delta_new"(s) SELECT t0.s FROM "dbrdf_Faculty_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Employee" ex WHERE ex.s = t0.s);


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


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#BasketBallFan$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_BasketBallFan_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#SportsLover$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_SportsLover_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#TennisFan$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_TennisFan_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#SportsFan$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_SportsFan_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#TeachingAssistant$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_TeachingAssistant_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#BaseballFan$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_BaseballFan_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#BasketBallLover$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_BasketBallLover_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#SwimmingLover$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_SwimmingLover_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Employee$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_Employee_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#BaseballLover$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_BaseballLover_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Chair$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_Chair_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#PeopleWithHobby$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_PeopleWithHobby_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Director$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_Director_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Student$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_Student_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


        -- <http://semantics.crl.ibm.com/univ-bench-dl.owl#Person$delta_new>(?X) :- <http://semantics.crl.ibm.com/univ-bench-dl.owl#SwimmingFan$delta_old>(?X) .
        INSERT INTO "dbrdf_Person_delta_new"(s) SELECT t0.s FROM "dbrdf_SwimmingFan_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Person" ex WHERE ex.s = t0.s);


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


        -- Propagate $delta_new

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

        INSERT INTO "dbrdf_Director"(s) SELECT DISTINCT t0.s 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_SportsFan"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsFan_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SportsFan_delta_old";
        INSERT INTO "dbrdf_SportsFan_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SportsFan_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SportsFan_delta_new";

        INSERT INTO "dbrdf_BaseballFan"(s) SELECT DISTINCT t0.s 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_TennisFan"(s) SELECT DISTINCT t0.s FROM "dbrdf_TennisFan_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_TennisFan_delta_old";
        INSERT INTO "dbrdf_TennisFan_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_TennisFan_delta_new" t0;
        TRUNCATE TABLE "dbrdf_TennisFan_delta_new";

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

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

        INSERT INTO "dbrdf_BaseballLover"(s) SELECT DISTINCT t0.s 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_SwimmingFan"(s) SELECT DISTINCT t0.s FROM "dbrdf_SwimmingFan_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SwimmingFan_delta_old";
        INSERT INTO "dbrdf_SwimmingFan_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SwimmingFan_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SwimmingFan_delta_new";

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

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

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

        INSERT INTO "dbrdf_Faculty"(s) SELECT DISTINCT t0.s 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"(s) SELECT DISTINCT t0.s 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"(s) SELECT DISTINCT t0.s 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_PeopleWithHobby"(s) SELECT DISTINCT t0.s FROM "dbrdf_PeopleWithHobby_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PeopleWithHobby_delta_old";
        INSERT INTO "dbrdf_PeopleWithHobby_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PeopleWithHobby_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PeopleWithHobby_delta_new";

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

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

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 127
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 128
    ---- DEPENDS ON: 127, 80, 92, 65, 64, 57, 47, 37, 84, 13, 1, 0
    ----------------------------------------

    -- Nonrecursive rules

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

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

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

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

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

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

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

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

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

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

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

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

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

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

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


        -- Propagate $delta_new

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

    END LOOP;

    -- END Recursive rules

    RETURN total_tuples;
END;
$$ LANGUAGE plpgsql;

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