CREATE OR REPLACE FUNCTION eiaodw.GCArg()
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := '{}'::int[];
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(
 a1 int4
)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := '{}'::int[];
   res := array_append(res, 1); -- 1 is int4
   res := array_append(res, a1);
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(
 a1 int4[]
)
RETURNS INT[] AS $$
DECLARE
 res INT[];
 temp INT;
BEGIN
   res := '{}'::int[];
   res := array_append(res, 10001); -- 10001 is int4[]
   temp := array_lower(a1, 1); IF temp IS NULL THEN temp := 0; END IF;
   res := array_append(res, temp);
   temp := array_upper(a1, 1); IF temp IS NULL THEN temp := -1; END IF;
   res := array_append(res, temp);
   res := array_cat(res, a1);
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0);
   res := array_cat(res, GCArg(a1));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0);
   res := array_cat(res, GCArg(a1));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0);
   res := array_cat(res, GCArg(a1));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0);
   res := array_cat(res, GCArg(a1));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1);
   res := array_cat(res, GCArg(a2));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1);
   res := array_cat(res, GCArg(a2));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1);
   res := array_cat(res, GCArg(a2));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1);
   res := array_cat(res, GCArg(a2));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1);
   res := array_cat(res, GCArg(a2));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1);
   res := array_cat(res, GCArg(a2));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1);
   res := array_cat(res, GCArg(a2));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1);
   res := array_cat(res, GCArg(a2));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2);
   res := array_cat(res, GCArg(a3));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4, a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4, a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4[], a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4[], a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4, a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4, a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4[], a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4[], a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4, a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4, a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4[], a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4[], a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4, a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4, a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4[], a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4[], a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4, a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4, a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4[], a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4[], a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4, a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4, a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4[], a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4[], a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4, a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4, a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4[], a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4[], a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4, a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4, a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4[], a4 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4[], a4 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3);
   res := array_cat(res, GCArg(a4));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4, a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4, a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4, a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4, a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4[], a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4[], a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4[], a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4, a3 INT4[], a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4, a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4, a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4, a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4, a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4[], a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4[], a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4[], a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4, a2 INT4[], a3 INT4[], a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4, a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4, a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4, a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4, a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4[], a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4[], a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4[], a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4, a3 INT4[], a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4, a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4, a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4, a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4, a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4[], a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4[], a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4[], a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4, a1 INT4[], a2 INT4[], a3 INT4[], a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4, a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4, a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4, a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4, a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4[], a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4[], a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4[], a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4, a3 INT4[], a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4, a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4, a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4, a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4, a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4[], a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4[], a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4[], a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4, a2 INT4[], a3 INT4[], a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4, a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4, a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4, a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4, a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4[], a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4[], a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4[], a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4, a3 INT4[], a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4, a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4, a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4, a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4, a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4[], a4 INT4, a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4[], a4 INT4, a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4[], a4 INT4[], a5 INT4)
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;

CREATE OR REPLACE FUNCTION eiaodw.GCArg(a0 INT4[], a1 INT4[], a2 INT4[], a3 INT4[], a4 INT4[], a5 INT4[])
RETURNS INT[] AS $$
DECLARE
 res INT[];
BEGIN
   res := GCArg(a0, a1, a2, a3, a4);
   res := array_cat(res, GCArg(a5));
   RETURN res;
END;
$$ LANGUAGE plpgsql IMMUTABLE;