Adding upstream version 13.4.upstream/13.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

15 files changed, 6766 insertions, 0 deletions

diff --git a/contrib/isn/.gitignore b/contrib/isn/.gitignore
new file mode 100644
index 0000000..5dcb3ff
--- /dev/null
+++ b/contrib/isn/.gitignore
@@ -0,0 +1,4 @@
+# Generated subdirectories
+/log/
+/results/
+/tmp_check/
diff --git a/contrib/isn/EAN13.h b/contrib/isn/EAN13.h
new file mode 100644
index 0000000..7023ebd
--- /dev/null
+++ b/contrib/isn/EAN13.h
@@ -0,0 +1,148 @@
+/*
+ * EAN13.h
+ *	  PostgreSQL type definitions for ISNs (ISBN, ISMN, ISSN, EAN13, UPC)
+ *
+ * Information recompiled by Kronuz on August 23, 2006
+ * http://www.gs1.org/productssolutions/idkeys/support/prefix_list.html
+ *
+ * IDENTIFICATION
+ *	  contrib/isn/EAN13.h
+ *
+ */
+
+/* where the digit set begins, and how many of them are in the table */
+const unsigned EAN13_index[10][2] = {
+	{0, 6},
+	{6, 1},
+	{7, 1},
+	{8, 5},
+	{13, 20},
+	{33, 15},
+	{48, 19},
+	{67, 23},
+	{90, 17},
+	{107, 12},
+};
+const char *EAN13_range[][2] = {
+	{"000", "019"},				/* GS1 US */
+	{"020", "029"},				/* Restricted distribution (MO defined) */
+	{"030", "039"},				/* GS1 US */
+	{"040", "049"},				/* Restricted distribution (MO defined) */
+	{"050", "059"},				/* Coupons */
+	{"060", "099"},				/* GS1 US */
+	{"100", "139"},				/* GS1 US */
+	{"200", "299"},				/* Restricted distribution (MO defined) */
+	{"300", "379"},				/* GS1 France */
+	{"380", "380"},				/* GS1 Bulgaria */
+	{"383", "383"},				/* GS1 Slovenija */
+	{"385", "385"},				/* GS1 Croatia */
+	{"387", "387"},				/* GS1 BIH (Bosnia-Herzegovina) */
+	{"400", "440"},				/* GS1 Germany */
+	{"450", "459"},				/* GS1 Japan */
+	{"460", "469"},				/* GS1 Russia */
+	{"470", "470"},				/* GS1 Kyrgyzstan */
+	{"471", "471"},				/* GS1 Taiwan */
+	{"474", "474"},				/* GS1 Estonia */
+	{"475", "475"},				/* GS1 Latvia */
+	{"476", "476"},				/* GS1 Azerbaijan */
+	{"477", "477"},				/* GS1 Lithuania */
+	{"478", "478"},				/* GS1 Uzbekistan */
+	{"479", "479"},				/* GS1 Sri Lanka */
+	{"480", "480"},				/* GS1 Philippines */
+	{"481", "481"},				/* GS1 Belarus */
+	{"482", "482"},				/* GS1 Ukraine */
+	{"484", "484"},				/* GS1 Moldova */
+	{"485", "485"},				/* GS1 Armenia */
+	{"486", "486"},				/* GS1 Georgia */
+	{"487", "487"},				/* GS1 Kazakstan */
+	{"489", "489"},				/* GS1 Hong Kong */
+	{"490", "499"},				/* GS1 Japan */
+	{"500", "509"},				/* GS1 UK */
+	{"520", "520"},				/* GS1 Greece */
+	{"528", "528"},				/* GS1 Lebanon */
+	{"529", "529"},				/* GS1 Cyprus */
+	{"530", "530"},				/* GS1 Albania */
+	{"531", "531"},				/* GS1 MAC (FYR Macedonia) */
+	{"535", "535"},				/* GS1 Malta */
+	{"539", "539"},				/* GS1 Ireland */
+	{"540", "549"},				/* GS1 Belgium & Luxembourg */
+	{"560", "560"},				/* GS1 Portugal */
+	{"569", "569"},				/* GS1 Iceland */
+	{"570", "579"},				/* GS1 Denmark */
+	{"590", "590"},				/* GS1 Poland */
+	{"594", "594"},				/* GS1 Romania */
+	{"599", "599"},				/* GS1 Hungary */
+	{"600", "601"},				/* GS1 South Africa */
+	{"603", "603"},				/* GS1 Ghana */
+	{"608", "608"},				/* GS1 Bahrain */
+	{"609", "609"},				/* GS1 Mauritius */
+	{"611", "611"},				/* GS1 Morocco */
+	{"613", "613"},				/* GS1 Algeria */
+	{"616", "616"},				/* GS1 Kenya */
+	{"618", "618"},				/* GS1 Ivory Coast */
+	{"619", "619"},				/* GS1 Tunisia */
+	{"621", "621"},				/* GS1 Syria */
+	{"622", "622"},				/* GS1 Egypt */
+	{"624", "624"},				/* GS1 Libya */
+	{"625", "625"},				/* GS1 Jordan */
+	{"626", "626"},				/* GS1 Iran */
+	{"627", "627"},				/* GS1 Kuwait */
+	{"628", "628"},				/* GS1 Saudi Arabia */
+	{"629", "629"},				/* GS1 Emirates */
+	{"640", "649"},				/* GS1 Finland */
+	{"690", "695"},				/* GS1 China */
+	{"700", "709"},				/* GS1 Norway */
+	{"729", "729"},				/* GS1 Israel */
+	{"730", "739"},				/* GS1 Sweden */
+	{"740", "740"},				/* GS1 Guatemala */
+	{"741", "741"},				/* GS1 El Salvador */
+	{"742", "742"},				/* GS1 Honduras */
+	{"743", "743"},				/* GS1 Nicaragua */
+	{"744", "744"},				/* GS1 Costa Rica */
+	{"745", "745"},				/* GS1 Panama */
+	{"746", "746"},				/* GS1 Republica Dominicana */
+	{"750", "750"},				/* GS1 Mexico */
+	{"754", "755"},				/* GS1 Canada */
+	{"759", "759"},				/* GS1 Venezuela */
+	{"760", "769"},				/* GS1 Schweiz, Suisse, Svizzera */
+	{"770", "770"},				/* GS1 Colombia */
+	{"773", "773"},				/* GS1 Uruguay */
+	{"775", "775"},				/* GS1 Peru */
+	{"777", "777"},				/* GS1 Bolivia */
+	{"779", "779"},				/* GS1 Argentina */
+	{"780", "780"},				/* GS1 Chile */
+	{"784", "784"},				/* GS1 Paraguay */
+	{"786", "786"},				/* GS1 Ecuador */
+	{"789", "790"},				/* GS1 Brasil */
+	{"800", "839"},				/* GS1 Italy */
+	{"840", "849"},				/* GS1 Spain */
+	{"850", "850"},				/* GS1 Cuba */
+	{"858", "858"},				/* GS1 Slovakia */
+	{"859", "859"},				/* GS1 Czech */
+	{"860", "860"},				/* GS1 YU (Serbia & Montenegro) */
+	{"865", "865"},				/* GS1 Mongolia */
+	{"867", "867"},				/* GS1 North Korea */
+	{"869", "869"},				/* GS1 Turkey */
+	{"870", "879"},				/* GS1 Netherlands */
+	{"880", "880"},				/* GS1 South Korea */
+	{"884", "884"},				/* GS1 Cambodia */
+	{"885", "885"},				/* GS1 Thailand */
+	{"888", "888"},				/* GS1 Singapore */
+	{"890", "890"},				/* GS1 India */
+	{"893", "893"},				/* GS1 Vietnam */
+	{"899", "899"},				/* GS1 Indonesia */
+	{"900", "919"},				/* GS1 Austria */
+	{"930", "939"},				/* GS1 Australia */
+	{"940", "949"},				/* GS1 New Zealand */
+	{"950", "950"},				/* GS1 Head Office */
+	{"955", "955"},				/* GS1 Malaysia */
+	{"958", "958"},				/* GS1 Macau */
+	{"977", "977"},				/* Serial publications (ISSN) */
+	{"978", "978"},				/* Bookland (ISBN) */
+	{"979", "979"},				/* International Standard Music Number (ISMN)
+								 * and ISBN contingent */
+	{"980", "980"},				/* Refund receipts */
+	{"981", "982"},				/* Common Currency Coupons */
+	{"990", "999"},				/* Coupons */
+	{NULL, NULL}
+};
diff --git a/contrib/isn/ISBN.h b/contrib/isn/ISBN.h
new file mode 100644
index 0000000..dbda6fb
--- /dev/null
+++ b/contrib/isn/ISBN.h
@@ -0,0 +1,990 @@
+/*
+ * ISBN.h
+ *	  PostgreSQL type definitions for ISNs (ISBN, ISMN, ISSN, EAN13, UPC)
+ *
+ * Information recompiled by Kronuz on June 20, 2006
+ * http://www.isbn-international.org/
+ * http://www.isbn.org/
+ *
+ * IDENTIFICATION
+ *	  contrib/isn/ISBN.h
+ *
+ * 0-393-04002-X => 039304002(X) <=> 039304002 <=> (978)039304002 <=> 978039304002(9) <=> 978-0-393-04002-9
+ *
+ *
+ * ISBN			0	3	 9	  3    0   4	0	0	2
+ * Weight		10	9	 8	  7    6   5	4	3	2
+ * Product		0 + 27 + 72 + 21 + 0 + 20 + 0 + 0 + 4 = 144
+ *				144 / 11 = 13 remainder 1
+ * Check digit	11 - 1 = 10 = X
+ * => 0-393-04002-X
+ *
+ * ISBN			9	7	 8	 0	 3	 9	  3   0   4   0   0   2
+ * Weight		1	3	 1	 3	 1	 3	  1   3   1   3   1   3
+ * Product		9 + 21 + 8 + 0 + 3 + 27 + 3 + 0 + 4 + 0 + 0 + 6 = 81
+ *				81 / 10 = 8 remainder 1
+ * Check digit	10 - 1 = 9
+ * => 978-0-393-04002-9
+ *
+ */
+
+/*
+ * For ISBN with prefix 978
+ * Range Table as of 2010-Jul-29
+ */
+
+/* where the digit set begins, and how many of them are in the table */
+const unsigned ISBN_index[10][2] = {
+	{0, 6},
+	{6, 6},
+	{12, 8},
+	{20, 14},
+	{34, 6},
+	{40, 19},
+	{59, 68},
+	{127, 5},
+	{132, 60},
+	{192, 718},
+};
+
+const char *ISBN_range[][2] = {
+	{"0-00", "0-19"},
+	{"0-200", "0-699"},
+	{"0-7000", "0-8499"},
+	{"0-85000", "0-89999"},
+	{"0-900000", "0-949999"},
+	{"0-9500000", "0-9999999"},
+	{"1-00", "1-09"},
+	{"1-100", "1-399"},
+	{"1-4000", "1-5499"},
+	{"1-55000", "1-86979"},
+	{"1-869800", "1-998999"},
+	{"1-9990000", "1-9999999"},
+	{"2-00", "2-19"},
+	{"2-200", "2-349"},
+	{"2-35000", "2-39999"},
+	{"2-400", "2-699"},
+	{"2-7000", "2-8399"},
+	{"2-84000", "2-89999"},
+	{"2-900000", "2-949999"},
+	{"2-9500000", "2-9999999"},
+	{"3-00", "3-02"},
+	{"3-030", "3-033"},
+	{"3-0340", "3-0369"},
+	{"3-03700", "3-03999"},
+	{"3-04", "3-19"},
+	{"3-200", "3-699"},
+	{"3-7000", "3-8499"},
+	{"3-85000", "3-89999"},
+	{"3-900000", "3-949999"},
+	{"3-9500000", "3-9539999"},
+	{"3-95400", "3-96999"},
+	{"3-9700000", "3-9899999"},
+	{"3-99000", "3-99499"},
+	{"3-99500", "3-99999"},
+	{"4-00", "4-19"},
+	{"4-200", "4-699"},
+	{"4-7000", "4-8499"},
+	{"4-85000", "4-89999"},
+	{"4-900000", "4-949999"},
+	{"4-9500000", "4-9999999"},
+	{"5-00", "5-19"},
+	{"5-200", "5-420"},
+	{"5-4210", "5-4299"},
+	{"5-430", "5-430"},
+	{"5-4310", "5-4399"},
+	{"5-440", "5-440"},
+	{"5-4410", "5-4499"},
+	{"5-450", "5-699"},
+	{"5-7000", "5-8499"},
+	{"5-85000", "5-89999"},
+	{"5-900000", "5-909999"},
+	{"5-91000", "5-91999"},
+	{"5-9200", "5-9299"},
+	{"5-93000", "5-94999"},
+	{"5-9500000", "5-9500999"},
+	{"5-9501", "5-9799"},
+	{"5-98000", "5-98999"},
+	{"5-9900000", "5-9909999"},
+	{"5-9910", "5-9999"},
+	{"600-00", "600-09"},
+	{"600-100", "600-499"},
+	{"600-5000", "600-8999"},
+	{"600-90000", "600-99999"},
+	{"601-00", "601-19"},
+	{"601-200", "601-699"},
+	{"601-7000", "601-7999"},
+	{"601-80000", "601-84999"},
+	{"601-85", "601-99"},
+	{"602-00", "602-19"},
+	{"602-200", "602-799"},
+	{"602-8000", "602-9499"},
+	{"602-95000", "602-99999"},
+	{"603-00", "603-04"},
+	{"603-05", "603-49"},
+	{"603-500", "603-799"},
+	{"603-8000", "603-8999"},
+	{"603-90000", "603-99999"},
+	{"604-0", "604-4"},
+	{"604-50", "604-89"},
+	{"604-900", "604-979"},
+	{"604-9800", "604-9999"},
+	{"605-01", "605-09"},
+	{"605-100", "605-399"},
+	{"605-4000", "605-5999"},
+	{"605-60000", "605-89999"},
+	{"605-90", "605-99"},
+	{"606-0", "606-0"},
+	{"606-10", "606-49"},
+	{"606-500", "606-799"},
+	{"606-8000", "606-9199"},
+	{"606-92000", "606-99999"},
+	{"607-00", "607-39"},
+	{"607-400", "607-749"},
+	{"607-7500", "607-9499"},
+	{"607-95000", "607-99999"},
+	{"608-0", "608-0"},
+	{"608-10", "608-19"},
+	{"608-200", "608-449"},
+	{"608-4500", "608-6499"},
+	{"608-65000", "608-69999"},
+	{"608-7", "608-9"},
+	{"609-00", "609-39"},
+	{"609-400", "609-799"},
+	{"609-8000", "609-9499"},
+	{"609-95000", "609-99999"},
+	{"612-00", "612-29"},
+	{"612-300", "612-399"},
+	{"612-4000", "612-4499"},
+	{"612-45000", "612-49999"},
+	{"612-50", "612-99"},
+	{"613-0", "613-9"},
+	{"614-00", "614-39"},
+	{"614-400", "614-799"},
+	{"614-8000", "614-9499"},
+	{"614-95000", "614-99999"},
+	{"615-00", "615-09"},
+	{"615-100", "615-499"},
+	{"615-5000", "615-7999"},
+	{"615-80000", "615-89999"},
+	{"616-00", "616-19"},
+	{"616-200", "616-699"},
+	{"616-7000", "616-8999"},
+	{"616-90000", "616-99999"},
+	{"617-00", "617-49"},
+	{"617-500", "617-699"},
+	{"617-7000", "617-8999"},
+	{"617-90000", "617-99999"},
+	{"7-00", "7-09"},
+	{"7-100", "7-499"},
+	{"7-5000", "7-7999"},
+	{"7-80000", "7-89999"},
+	{"7-900000", "7-999999"},
+	{"80-00", "80-19"},
+	{"80-200", "80-699"},
+	{"80-7000", "80-8499"},
+	{"80-85000", "80-89999"},
+	{"80-900000", "80-999999"},
+	{"81-00", "81-19"},
+	{"81-200", "81-699"},
+	{"81-7000", "81-8499"},
+	{"81-85000", "81-89999"},
+	{"81-900000", "81-999999"},
+	{"82-00", "82-19"},
+	{"82-200", "82-699"},
+	{"82-7000", "82-8999"},
+	{"82-90000", "82-98999"},
+	{"82-990000", "82-999999"},
+	{"83-00", "83-19"},
+	{"83-200", "83-599"},
+	{"83-60000", "83-69999"},
+	{"83-7000", "83-8499"},
+	{"83-85000", "83-89999"},
+	{"83-900000", "83-999999"},
+	{"84-00", "84-14"},
+	{"84-15000", "84-19999"},
+	{"84-200", "84-699"},
+	{"84-7000", "84-8499"},
+	{"84-85000", "84-89999"},
+	{"84-9000", "84-9199"},
+	{"84-920000", "84-923999"},
+	{"84-92400", "84-92999"},
+	{"84-930000", "84-949999"},
+	{"84-95000", "84-96999"},
+	{"84-9700", "84-9999"},
+	{"85-00", "85-19"},
+	{"85-200", "85-599"},
+	{"85-60000", "85-69999"},
+	{"85-7000", "85-8499"},
+	{"85-85000", "85-89999"},
+	{"85-900000", "85-979999"},
+	{"85-98000", "85-99999"},
+	{"86-00", "86-29"},
+	{"86-300", "86-599"},
+	{"86-6000", "86-7999"},
+	{"86-80000", "86-89999"},
+	{"86-900000", "86-999999"},
+	{"87-00", "87-29"},
+	{"87-400", "87-649"},
+	{"87-7000", "87-7999"},
+	{"87-85000", "87-94999"},
+	{"87-970000", "87-999999"},
+	{"88-00", "88-19"},
+	{"88-200", "88-599"},
+	{"88-6000", "88-8499"},
+	{"88-85000", "88-89999"},
+	{"88-900000", "88-949999"},
+	{"88-95000", "88-99999"},
+	{"89-00", "89-24"},
+	{"89-250", "89-549"},
+	{"89-5500", "89-8499"},
+	{"89-85000", "89-94999"},
+	{"89-950000", "89-999999"},
+	{"90-00", "90-19"},
+	{"90-200", "90-499"},
+	{"90-5000", "90-6999"},
+	{"90-70000", "90-79999"},
+	{"90-800000", "90-849999"},
+	{"90-8500", "90-8999"},
+	{"90-90", "90-90"},
+	{"90-910000", "90-939999"},
+	{"90-94", "90-94"},
+	{"90-950000", "90-999999"},
+	{"91-0", "91-1"},
+	{"91-20", "91-49"},
+	{"91-500", "91-649"},
+	{"91-7000", "91-7999"},
+	{"91-85000", "91-94999"},
+	{"91-970000", "91-999999"},
+	{"92-0", "92-5"},
+	{"92-60", "92-79"},
+	{"92-800", "92-899"},
+	{"92-9000", "92-9499"},
+	{"92-95000", "92-98999"},
+	{"92-990000", "92-999999"},
+	{"93-00", "93-09"},
+	{"93-100", "93-499"},
+	{"93-5000", "93-7999"},
+	{"93-80000", "93-94999"},
+	{"93-950000", "93-999999"},
+	{"94-000", "94-599"},
+	{"94-6000", "94-8999"},
+	{"94-90000", "94-99999"},
+	{"950-00", "950-49"},
+	{"950-500", "950-899"},
+	{"950-9000", "950-9899"},
+	{"950-99000", "950-99999"},
+	{"951-0", "951-1"},
+	{"951-20", "951-54"},
+	{"951-550", "951-889"},
+	{"951-8900", "951-9499"},
+	{"951-95000", "951-99999"},
+	{"952-00", "952-19"},
+	{"952-200", "952-499"},
+	{"952-5000", "952-5999"},
+	{"952-60", "952-65"},
+	{"952-6600", "952-6699"},
+	{"952-67000", "952-69999"},
+	{"952-7000", "952-7999"},
+	{"952-80", "952-94"},
+	{"952-9500", "952-9899"},
+	{"952-99000", "952-99999"},
+	{"953-0", "953-0"},
+	{"953-10", "953-14"},
+	{"953-150", "953-549"},
+	{"953-55000", "953-59999"},
+	{"953-6000", "953-9499"},
+	{"953-95000", "953-99999"},
+	{"954-00", "954-28"},
+	{"954-2900", "954-2999"},
+	{"954-300", "954-799"},
+	{"954-8000", "954-8999"},
+	{"954-90000", "954-92999"},
+	{"954-9300", "954-9999"},
+	{"955-0000", "955-1999"},
+	{"955-20", "955-49"},
+	{"955-50000", "955-54999"},
+	{"955-550", "955-799"},
+	{"955-8000", "955-9499"},
+	{"955-95000", "955-99999"},
+	{"956-00", "956-19"},
+	{"956-200", "956-699"},
+	{"956-7000", "956-9999"},
+	{"957-00", "957-02"},
+	{"957-0300", "957-0499"},
+	{"957-05", "957-19"},
+	{"957-2000", "957-2099"},
+	{"957-21", "957-27"},
+	{"957-28000", "957-30999"},
+	{"957-31", "957-43"},
+	{"957-440", "957-819"},
+	{"957-8200", "957-9699"},
+	{"957-97000", "957-99999"},
+	{"958-00", "958-56"},
+	{"958-57000", "958-59999"},
+	{"958-600", "958-799"},
+	{"958-8000", "958-9499"},
+	{"958-95000", "958-99999"},
+	{"959-00", "959-19"},
+	{"959-200", "959-699"},
+	{"959-7000", "959-8499"},
+	{"959-85000", "959-99999"},
+	{"960-00", "960-19"},
+	{"960-200", "960-659"},
+	{"960-6600", "960-6899"},
+	{"960-690", "960-699"},
+	{"960-7000", "960-8499"},
+	{"960-85000", "960-92999"},
+	{"960-93", "960-93"},
+	{"960-9400", "960-9799"},
+	{"960-98000", "960-99999"},
+	{"961-00", "961-19"},
+	{"961-200", "961-599"},
+	{"961-6000", "961-8999"},
+	{"961-90000", "961-94999"},
+	{"962-00", "962-19"},
+	{"962-200", "962-699"},
+	{"962-7000", "962-8499"},
+	{"962-85000", "962-86999"},
+	{"962-8700", "962-8999"},
+	{"962-900", "962-999"},
+	{"963-00", "963-19"},
+	{"963-200", "963-699"},
+	{"963-7000", "963-8499"},
+	{"963-85000", "963-89999"},
+	{"963-9000", "963-9999"},
+	{"964-00", "964-14"},
+	{"964-150", "964-249"},
+	{"964-2500", "964-2999"},
+	{"964-300", "964-549"},
+	{"964-5500", "964-8999"},
+	{"964-90000", "964-96999"},
+	{"964-970", "964-989"},
+	{"964-9900", "964-9999"},
+	{"965-00", "965-19"},
+	{"965-200", "965-599"},
+	{"965-7000", "965-7999"},
+	{"965-90000", "965-99999"},
+	{"966-00", "966-14"},
+	{"966-1500", "966-1699"},
+	{"966-170", "966-199"},
+	{"966-2000", "966-2999"},
+	{"966-300", "966-699"},
+	{"966-7000", "966-8999"},
+	{"966-90000", "966-99999"},
+	{"967-00", "967-29"},
+	{"967-300", "967-499"},
+	{"967-5000", "967-5999"},
+	{"967-60", "967-89"},
+	{"967-900", "967-989"},
+	{"967-9900", "967-9989"},
+	{"967-99900", "967-99999"},
+	{"968-01", "968-39"},
+	{"968-400", "968-499"},
+	{"968-5000", "968-7999"},
+	{"968-800", "968-899"},
+	{"968-9000", "968-9999"},
+	{"969-0", "969-1"},
+	{"969-20", "969-39"},
+	{"969-400", "969-799"},
+	{"969-8000", "969-9999"},
+	{"970-01", "970-59"},
+	{"970-600", "970-899"},
+	{"970-9000", "970-9099"},
+	{"970-91000", "970-96999"},
+	{"970-9700", "970-9999"},
+	{"971-000", "971-015"},
+	{"971-0160", "971-0199"},
+	{"971-02", "971-02"},
+	{"971-0300", "971-0599"},
+	{"971-06", "971-09"},
+	{"971-10", "971-49"},
+	{"971-500", "971-849"},
+	{"971-8500", "971-9099"},
+	{"971-91000", "971-98999"},
+	{"971-9900", "971-9999"},
+	{"972-0", "972-1"},
+	{"972-20", "972-54"},
+	{"972-550", "972-799"},
+	{"972-8000", "972-9499"},
+	{"972-95000", "972-99999"},
+	{"973-0", "973-0"},
+	{"973-100", "973-169"},
+	{"973-1700", "973-1999"},
+	{"973-20", "973-54"},
+	{"973-550", "973-759"},
+	{"973-7600", "973-8499"},
+	{"973-85000", "973-88999"},
+	{"973-8900", "973-9499"},
+	{"973-95000", "973-99999"},
+	{"974-00", "974-19"},
+	{"974-200", "974-699"},
+	{"974-7000", "974-8499"},
+	{"974-85000", "974-89999"},
+	{"974-90000", "974-94999"},
+	{"974-9500", "974-9999"},
+	{"975-00000", "975-00999"},
+	{"975-01", "975-01"},
+	{"975-02", "975-24"},
+	{"975-250", "975-599"},
+	{"975-6000", "975-9199"},
+	{"975-92000", "975-98999"},
+	{"975-990", "975-999"},
+	{"976-0", "976-3"},
+	{"976-40", "976-59"},
+	{"976-600", "976-799"},
+	{"976-8000", "976-9499"},
+	{"976-95000", "976-99999"},
+	{"977-00", "977-19"},
+	{"977-200", "977-499"},
+	{"977-5000", "977-6999"},
+	{"977-700", "977-999"},
+	{"978-000", "978-199"},
+	{"978-2000", "978-2999"},
+	{"978-30000", "978-79999"},
+	{"978-8000", "978-8999"},
+	{"978-900", "978-999"},
+	{"979-000", "979-099"},
+	{"979-1000", "979-1499"},
+	{"979-15000", "979-19999"},
+	{"979-20", "979-29"},
+	{"979-3000", "979-3999"},
+	{"979-400", "979-799"},
+	{"979-8000", "979-9499"},
+	{"979-95000", "979-99999"},
+	{"980-00", "980-19"},
+	{"980-200", "980-599"},
+	{"980-6000", "980-9999"},
+	{"981-00", "981-11"},
+	{"981-1200", "981-1999"},
+	{"981-200", "981-289"},
+	{"981-2900", "981-9999"},
+	{"982-00", "982-09"},
+	{"982-100", "982-699"},
+	{"982-70", "982-89"},
+	{"982-9000", "982-9799"},
+	{"982-98000", "982-99999"},
+	{"983-00", "983-01"},
+	{"983-020", "983-199"},
+	{"983-2000", "983-3999"},
+	{"983-40000", "983-44999"},
+	{"983-45", "983-49"},
+	{"983-50", "983-79"},
+	{"983-800", "983-899"},
+	{"983-9000", "983-9899"},
+	{"983-99000", "983-99999"},
+	{"984-00", "984-39"},
+	{"984-400", "984-799"},
+	{"984-8000", "984-8999"},
+	{"984-90000", "984-99999"},
+	{"985-00", "985-39"},
+	{"985-400", "985-599"},
+	{"985-6000", "985-8999"},
+	{"985-90000", "985-99999"},
+	{"986-00", "986-11"},
+	{"986-120", "986-559"},
+	{"986-5600", "986-7999"},
+	{"986-80000", "986-99999"},
+	{"987-00", "987-09"},
+	{"987-1000", "987-1999"},
+	{"987-20000", "987-29999"},
+	{"987-30", "987-49"},
+	{"987-500", "987-899"},
+	{"987-9000", "987-9499"},
+	{"987-95000", "987-99999"},
+	{"988-00", "988-16"},
+	{"988-17000", "988-19999"},
+	{"988-200", "988-799"},
+	{"988-8000", "988-9699"},
+	{"988-97000", "988-99999"},
+	{"989-0", "989-1"},
+	{"989-20", "989-54"},
+	{"989-550", "989-799"},
+	{"989-8000", "989-9499"},
+	{"989-95000", "989-99999"},
+	{"9927-00", "9927-09"},
+	{"9927-100", "9927-399"},
+	{"9927-4000", "9927-4999"},
+	{"9928-00", "9928-09"},
+	{"9928-100", "9928-399"},
+	{"9928-4000", "9928-4999"},
+	{"9929-0", "9929-3"},
+	{"9929-40", "9929-54"},
+	{"9929-550", "9929-799"},
+	{"9929-8000", "9929-9999"},
+	{"9930-00", "9930-49"},
+	{"9930-500", "9930-939"},
+	{"9930-9400", "9930-9999"},
+	{"9931-00", "9931-29"},
+	{"9931-300", "9931-899"},
+	{"9931-9000", "9931-9999"},
+	{"9932-00", "9932-39"},
+	{"9932-400", "9932-849"},
+	{"9932-8500", "9932-9999"},
+	{"9933-0", "9933-0"},
+	{"9933-10", "9933-39"},
+	{"9933-400", "9933-899"},
+	{"9933-9000", "9933-9999"},
+	{"9934-0", "9934-0"},
+	{"9934-10", "9934-49"},
+	{"9934-500", "9934-799"},
+	{"9934-8000", "9934-9999"},
+	{"9935-0", "9935-0"},
+	{"9935-10", "9935-39"},
+	{"9935-400", "9935-899"},
+	{"9935-9000", "9935-9999"},
+	{"9936-0", "9936-1"},
+	{"9936-20", "9936-39"},
+	{"9936-400", "9936-799"},
+	{"9936-8000", "9936-9999"},
+	{"9937-0", "9937-2"},
+	{"9937-30", "9937-49"},
+	{"9937-500", "9937-799"},
+	{"9937-8000", "9937-9999"},
+	{"9938-00", "9938-79"},
+	{"9938-800", "9938-949"},
+	{"9938-9500", "9938-9999"},
+	{"9939-0", "9939-4"},
+	{"9939-50", "9939-79"},
+	{"9939-800", "9939-899"},
+	{"9939-9000", "9939-9999"},
+	{"9940-0", "9940-1"},
+	{"9940-20", "9940-49"},
+	{"9940-500", "9940-899"},
+	{"9940-9000", "9940-9999"},
+	{"9941-0", "9941-0"},
+	{"9941-10", "9941-39"},
+	{"9941-400", "9941-899"},
+	{"9941-9000", "9941-9999"},
+	{"9942-00", "9942-89"},
+	{"9942-900", "9942-994"},
+	{"9942-9950", "9942-9999"},
+	{"9943-00", "9943-29"},
+	{"9943-300", "9943-399"},
+	{"9943-4000", "9943-9999"},
+	{"9944-0000", "9944-0999"},
+	{"9944-100", "9944-499"},
+	{"9944-5000", "9944-5999"},
+	{"9944-60", "9944-69"},
+	{"9944-700", "9944-799"},
+	{"9944-80", "9944-89"},
+	{"9944-900", "9944-999"},
+	{"9945-00", "9945-00"},
+	{"9945-010", "9945-079"},
+	{"9945-08", "9945-39"},
+	{"9945-400", "9945-569"},
+	{"9945-57", "9945-57"},
+	{"9945-580", "9945-849"},
+	{"9945-8500", "9945-9999"},
+	{"9946-0", "9946-1"},
+	{"9946-20", "9946-39"},
+	{"9946-400", "9946-899"},
+	{"9946-9000", "9946-9999"},
+	{"9947-0", "9947-1"},
+	{"9947-20", "9947-79"},
+	{"9947-800", "9947-999"},
+	{"9948-00", "9948-39"},
+	{"9948-400", "9948-849"},
+	{"9948-8500", "9948-9999"},
+	{"9949-0", "9949-0"},
+	{"9949-10", "9949-39"},
+	{"9949-400", "9949-899"},
+	{"9949-9000", "9949-9999"},
+	{"9950-00", "9950-29"},
+	{"9950-300", "9950-849"},
+	{"9950-8500", "9950-9999"},
+	{"9951-00", "9951-39"},
+	{"9951-400", "9951-849"},
+	{"9951-8500", "9951-9999"},
+	{"9952-0", "9952-1"},
+	{"9952-20", "9952-39"},
+	{"9952-400", "9952-799"},
+	{"9952-8000", "9952-9999"},
+	{"9953-0", "9953-0"},
+	{"9953-10", "9953-39"},
+	{"9953-400", "9953-599"},
+	{"9953-60", "9953-89"},
+	{"9953-9000", "9953-9999"},
+	{"9954-0", "9954-1"},
+	{"9954-20", "9954-39"},
+	{"9954-400", "9954-799"},
+	{"9954-8000", "9954-9999"},
+	{"9955-00", "9955-39"},
+	{"9955-400", "9955-929"},
+	{"9955-9300", "9955-9999"},
+	{"9956-0", "9956-0"},
+	{"9956-10", "9956-39"},
+	{"9956-400", "9956-899"},
+	{"9956-9000", "9956-9999"},
+	{"9957-00", "9957-39"},
+	{"9957-400", "9957-699"},
+	{"9957-70", "9957-84"},
+	{"9957-8500", "9957-8799"},
+	{"9957-88", "9957-99"},
+	{"9958-0", "9958-0"},
+	{"9958-10", "9958-49"},
+	{"9958-500", "9958-899"},
+	{"9958-9000", "9958-9999"},
+	{"9959-0", "9959-1"},
+	{"9959-20", "9959-79"},
+	{"9959-800", "9959-949"},
+	{"9959-9500", "9959-9999"},
+	{"9960-00", "9960-59"},
+	{"9960-600", "9960-899"},
+	{"9960-9000", "9960-9999"},
+	{"9961-0", "9961-2"},
+	{"9961-30", "9961-69"},
+	{"9961-700", "9961-949"},
+	{"9961-9500", "9961-9999"},
+	{"9962-00", "9962-54"},
+	{"9962-5500", "9962-5599"},
+	{"9962-56", "9962-59"},
+	{"9962-600", "9962-849"},
+	{"9962-8500", "9962-9999"},
+	{"9963-0", "9963-2"},
+	{"9963-30", "9963-54"},
+	{"9963-550", "9963-734"},
+	{"9963-7350", "9963-7499"},
+	{"9963-7500", "9963-9999"},
+	{"9964-0", "9964-6"},
+	{"9964-70", "9964-94"},
+	{"9964-950", "9964-999"},
+	{"9965-00", "9965-39"},
+	{"9965-400", "9965-899"},
+	{"9965-9000", "9965-9999"},
+	{"9966-000", "9966-199"},
+	{"9966-20", "9966-69"},
+	{"9966-7000", "9966-7499"},
+	{"9966-750", "9966-959"},
+	{"9966-9600", "9966-9999"},
+	{"9967-00", "9967-39"},
+	{"9967-400", "9967-899"},
+	{"9967-9000", "9967-9999"},
+	{"9968-00", "9968-49"},
+	{"9968-500", "9968-939"},
+	{"9968-9400", "9968-9999"},
+	{"9970-00", "9970-39"},
+	{"9970-400", "9970-899"},
+	{"9970-9000", "9970-9999"},
+	{"9971-0", "9971-5"},
+	{"9971-60", "9971-89"},
+	{"9971-900", "9971-989"},
+	{"9971-9900", "9971-9999"},
+	{"9972-00", "9972-09"},
+	{"9972-1", "9972-1"},
+	{"9972-200", "9972-249"},
+	{"9972-2500", "9972-2999"},
+	{"9972-30", "9972-59"},
+	{"9972-600", "9972-899"},
+	{"9972-9000", "9972-9999"},
+	{"9973-00", "9973-05"},
+	{"9973-060", "9973-089"},
+	{"9973-0900", "9973-0999"},
+	{"9973-10", "9973-69"},
+	{"9973-700", "9973-969"},
+	{"9973-9700", "9973-9999"},
+	{"9974-0", "9974-2"},
+	{"9974-30", "9974-54"},
+	{"9974-550", "9974-749"},
+	{"9974-7500", "9974-9499"},
+	{"9974-95", "9974-99"},
+	{"9975-0", "9975-0"},
+	{"9975-100", "9975-399"},
+	{"9975-4000", "9975-4499"},
+	{"9975-45", "9975-89"},
+	{"9975-900", "9975-949"},
+	{"9975-9500", "9975-9999"},
+	{"9976-0", "9976-5"},
+	{"9976-60", "9976-89"},
+	{"9976-900", "9976-989"},
+	{"9976-9900", "9976-9999"},
+	{"9977-00", "9977-89"},
+	{"9977-900", "9977-989"},
+	{"9977-9900", "9977-9999"},
+	{"9978-00", "9978-29"},
+	{"9978-300", "9978-399"},
+	{"9978-40", "9978-94"},
+	{"9978-950", "9978-989"},
+	{"9978-9900", "9978-9999"},
+	{"9979-0", "9979-4"},
+	{"9979-50", "9979-64"},
+	{"9979-650", "9979-659"},
+	{"9979-66", "9979-75"},
+	{"9979-760", "9979-899"},
+	{"9979-9000", "9979-9999"},
+	{"9980-0", "9980-3"},
+	{"9980-40", "9980-89"},
+	{"9980-900", "9980-989"},
+	{"9980-9900", "9980-9999"},
+	{"9981-00", "9981-09"},
+	{"9981-100", "9981-159"},
+	{"9981-1600", "9981-1999"},
+	{"9981-20", "9981-79"},
+	{"9981-800", "9981-949"},
+	{"9981-9500", "9981-9999"},
+	{"9982-00", "9982-79"},
+	{"9982-800", "9982-989"},
+	{"9982-9900", "9982-9999"},
+	{"9983-80", "9983-94"},
+	{"9983-950", "9983-989"},
+	{"9983-9900", "9983-9999"},
+	{"9984-00", "9984-49"},
+	{"9984-500", "9984-899"},
+	{"9984-9000", "9984-9999"},
+	{"9985-0", "9985-4"},
+	{"9985-50", "9985-79"},
+	{"9985-800", "9985-899"},
+	{"9985-9000", "9985-9999"},
+	{"9986-00", "9986-39"},
+	{"9986-400", "9986-899"},
+	{"9986-9000", "9986-9399"},
+	{"9986-940", "9986-969"},
+	{"9986-97", "9986-99"},
+	{"9987-00", "9987-39"},
+	{"9987-400", "9987-879"},
+	{"9987-8800", "9987-9999"},
+	{"9988-0", "9988-2"},
+	{"9988-30", "9988-54"},
+	{"9988-550", "9988-749"},
+	{"9988-7500", "9988-9999"},
+	{"9989-0", "9989-0"},
+	{"9989-100", "9989-199"},
+	{"9989-2000", "9989-2999"},
+	{"9989-30", "9989-59"},
+	{"9989-600", "9989-949"},
+	{"9989-9500", "9989-9999"},
+	{"99901-00", "99901-49"},
+	{"99901-500", "99901-799"},
+	{"99901-80", "99901-99"},
+	{"99903-0", "99903-1"},
+	{"99903-20", "99903-89"},
+	{"99903-900", "99903-999"},
+	{"99904-0", "99904-5"},
+	{"99904-60", "99904-89"},
+	{"99904-900", "99904-999"},
+	{"99905-0", "99905-3"},
+	{"99905-40", "99905-79"},
+	{"99905-800", "99905-999"},
+	{"99906-0", "99906-2"},
+	{"99906-30", "99906-59"},
+	{"99906-600", "99906-699"},
+	{"99906-70", "99906-89"},
+	{"99906-90", "99906-94"},
+	{"99906-950", "99906-999"},
+	{"99908-0", "99908-0"},
+	{"99908-10", "99908-89"},
+	{"99908-900", "99908-999"},
+	{"99909-0", "99909-3"},
+	{"99909-40", "99909-94"},
+	{"99909-950", "99909-999"},
+	{"99910-0", "99910-2"},
+	{"99910-30", "99910-89"},
+	{"99910-900", "99910-999"},
+	{"99911-00", "99911-59"},
+	{"99911-600", "99911-999"},
+	{"99912-0", "99912-3"},
+	{"99912-400", "99912-599"},
+	{"99912-60", "99912-89"},
+	{"99912-900", "99912-999"},
+	{"99913-0", "99913-2"},
+	{"99913-30", "99913-35"},
+	{"99913-600", "99913-604"},
+	{"99914-0", "99914-4"},
+	{"99914-50", "99914-89"},
+	{"99914-900", "99914-999"},
+	{"99915-0", "99915-4"},
+	{"99915-50", "99915-79"},
+	{"99915-800", "99915-999"},
+	{"99916-0", "99916-2"},
+	{"99916-30", "99916-69"},
+	{"99916-700", "99916-999"},
+	{"99917-0", "99917-2"},
+	{"99917-30", "99917-89"},
+	{"99917-900", "99917-999"},
+	{"99918-0", "99918-3"},
+	{"99918-40", "99918-79"},
+	{"99918-800", "99918-999"},
+	{"99919-0", "99919-2"},
+	{"99919-300", "99919-399"},
+	{"99919-40", "99919-69"},
+	{"99919-900", "99919-999"},
+	{"99920-0", "99920-4"},
+	{"99920-50", "99920-89"},
+	{"99920-900", "99920-999"},
+	{"99921-0", "99921-1"},
+	{"99921-20", "99921-69"},
+	{"99921-700", "99921-799"},
+	{"99921-8", "99921-8"},
+	{"99921-90", "99921-99"},
+	{"99922-0", "99922-3"},
+	{"99922-40", "99922-69"},
+	{"99922-700", "99922-999"},
+	{"99923-0", "99923-1"},
+	{"99923-20", "99923-79"},
+	{"99923-800", "99923-999"},
+	{"99924-0", "99924-1"},
+	{"99924-20", "99924-79"},
+	{"99924-800", "99924-999"},
+	{"99925-0", "99925-3"},
+	{"99925-40", "99925-79"},
+	{"99925-800", "99925-999"},
+	{"99926-0", "99926-0"},
+	{"99926-10", "99926-59"},
+	{"99926-600", "99926-999"},
+	{"99927-0", "99927-2"},
+	{"99927-30", "99927-59"},
+	{"99927-600", "99927-999"},
+	{"99928-0", "99928-0"},
+	{"99928-10", "99928-79"},
+	{"99928-800", "99928-999"},
+	{"99929-0", "99929-4"},
+	{"99929-50", "99929-79"},
+	{"99929-800", "99929-999"},
+	{"99930-0", "99930-4"},
+	{"99930-50", "99930-79"},
+	{"99930-800", "99930-999"},
+	{"99931-0", "99931-4"},
+	{"99931-50", "99931-79"},
+	{"99931-800", "99931-999"},
+	{"99932-0", "99932-0"},
+	{"99932-10", "99932-59"},
+	{"99932-600", "99932-699"},
+	{"99932-7", "99932-7"},
+	{"99932-80", "99932-99"},
+	{"99933-0", "99933-2"},
+	{"99933-30", "99933-59"},
+	{"99933-600", "99933-999"},
+	{"99934-0", "99934-1"},
+	{"99934-20", "99934-79"},
+	{"99934-800", "99934-999"},
+	{"99935-0", "99935-2"},
+	{"99935-30", "99935-59"},
+	{"99935-600", "99935-699"},
+	{"99935-7", "99935-8"},
+	{"99935-90", "99935-99"},
+	{"99936-0", "99936-0"},
+	{"99936-10", "99936-59"},
+	{"99936-600", "99936-999"},
+	{"99937-0", "99937-1"},
+	{"99937-20", "99937-59"},
+	{"99937-600", "99937-999"},
+	{"99938-0", "99938-1"},
+	{"99938-20", "99938-59"},
+	{"99938-600", "99938-899"},
+	{"99938-90", "99938-99"},
+	{"99939-0", "99939-5"},
+	{"99939-60", "99939-89"},
+	{"99939-900", "99939-999"},
+	{"99940-0", "99940-0"},
+	{"99940-10", "99940-69"},
+	{"99940-700", "99940-999"},
+	{"99941-0", "99941-2"},
+	{"99941-30", "99941-79"},
+	{"99941-800", "99941-999"},
+	{"99942-0", "99942-4"},
+	{"99942-50", "99942-79"},
+	{"99942-800", "99942-999"},
+	{"99943-0", "99943-2"},
+	{"99943-30", "99943-59"},
+	{"99943-600", "99943-999"},
+	{"99944-0", "99944-4"},
+	{"99944-50", "99944-79"},
+	{"99944-800", "99944-999"},
+	{"99945-0", "99945-5"},
+	{"99945-60", "99945-89"},
+	{"99945-900", "99945-999"},
+	{"99946-0", "99946-2"},
+	{"99946-30", "99946-59"},
+	{"99946-600", "99946-999"},
+	{"99947-0", "99947-2"},
+	{"99947-30", "99947-69"},
+	{"99947-700", "99947-999"},
+	{"99948-0", "99948-4"},
+	{"99948-50", "99948-79"},
+	{"99948-800", "99948-999"},
+	{"99949-0", "99949-1"},
+	{"99949-20", "99949-89"},
+	{"99949-900", "99949-999"},
+	{"99950-0", "99950-4"},
+	{"99950-50", "99950-79"},
+	{"99950-800", "99950-999"},
+	{"99952-0", "99952-4"},
+	{"99952-50", "99952-79"},
+	{"99952-800", "99952-999"},
+	{"99953-0", "99953-2"},
+	{"99953-30", "99953-79"},
+	{"99953-800", "99953-939"},
+	{"99953-94", "99953-99"},
+	{"99954-0", "99954-2"},
+	{"99954-30", "99954-69"},
+	{"99954-700", "99954-999"},
+	{"99955-0", "99955-1"},
+	{"99955-20", "99955-59"},
+	{"99955-600", "99955-799"},
+	{"99955-80", "99955-89"},
+	{"99955-90", "99955-99"},
+	{"99956-00", "99956-59"},
+	{"99956-600", "99956-859"},
+	{"99956-86", "99956-99"},
+	{"99957-0", "99957-1"},
+	{"99957-20", "99957-79"},
+	{"99957-800", "99957-999"},
+	{"99958-0", "99958-4"},
+	{"99958-50", "99958-94"},
+	{"99958-950", "99958-999"},
+	{"99959-0", "99959-2"},
+	{"99959-30", "99959-59"},
+	{"99959-600", "99959-999"},
+	{"99960-0", "99960-0"},
+	{"99960-10", "99960-94"},
+	{"99960-950", "99960-999"},
+	{"99961-0", "99961-3"},
+	{"99961-40", "99961-89"},
+	{"99961-900", "99961-999"},
+	{"99962-0", "99962-4"},
+	{"99962-50", "99962-79"},
+	{"99962-800", "99962-999"},
+	{"99963-00", "99963-49"},
+	{"99963-500", "99963-999"},
+	{"99964-0", "99964-1"},
+	{"99964-20", "99964-79"},
+	{"99964-800", "99964-999"},
+	{"99965-0", "99965-3"},
+	{"99965-40", "99965-79"},
+	{"99965-800", "99965-999"},
+	{"99966-0", "99966-2"},
+	{"99966-30", "99966-69"},
+	{"99966-700", "99966-799"},
+	{"99967-0", "99967-1"},
+	{"99967-20", "99967-59"},
+	{"99967-600", "99967-899"},
+	{NULL, NULL},
+};
+
+/*
+ * For ISBN with prefix 979
+ * Range Table as of 2010-Jul-29
+ */
+
+/* where the digit set begins, and how many of them are in the table */
+const unsigned ISBN_index_new[10][2] = {
+	{0, 0},
+	{0, 5},
+	{5, 0},
+	{5, 0},
+	{5, 0},
+	{5, 0},
+	{5, 0},
+	{5, 0},
+	{5, 0},
+	{5, 0},
+};
+
+const char *ISBN_range_new[][2] = {
+	{"10-00", "10-19"},
+	{"10-200", "10-699"},
+	{"10-7000", "10-8999"},
+	{"10-90000", "10-97599"},
+	{"10-976000", "10-999999"},
+	{NULL, NULL},
+};
diff --git a/contrib/isn/ISMN.h b/contrib/isn/ISMN.h
new file mode 100644
index 0000000..281f2cd
--- /dev/null
+++ b/contrib/isn/ISMN.h
@@ -0,0 +1,52 @@
+/*
+ * ISMN.h
+ *	  PostgreSQL type definitions for ISNs (ISBN, ISMN, ISSN, EAN13, UPC)
+ *
+ * Information recompiled by Kronuz on November 12, 2004
+ * http://www.ismn-international.org
+ *
+ * IDENTIFICATION
+ *	  contrib/isn/ISMN.h
+ *
+ * M-3452-4680-5 <=> (0)-3452-4680-5 <=> 0345246805 <=> 9790345246805 <=> 979-0-3452-4680-5
+ *
+ *			   (M counts as 3)
+ * ISMN			M	3	4	 5	 2	 4	 6	  8   0
+ * Weight		3	1	3	 1	 3	 1	 3	  1   3
+ * Product		9 + 3 + 12 + 5 + 6 + 4 + 18 + 8 + 0 = 65
+ *				65 / 10 = 6 remainder 5
+ * Check digit	10 - 5 = 5
+ * => M-3452-4680-5
+ *
+ * ISMN			9	7	 9	 0	 3	 4	  5   2   4   6    8   0
+ * Weight		1	3	 1	 3	 1	 3	  1   3   1   3    1   3
+ * Product		9 + 21 + 9 + 0 + 3 + 12 + 5 + 6 + 4 + 18 + 8 + 0 = 95
+ *				95 / 10 = 9 remainder 5
+ * Check digit	10 - 5 = 5
+ * => 979-0-3452-4680-5
+ *
+ * Since mod10(9*1 + 7*3 + 9*1 + 0*3) = mod10(M*3) = mod10(3*3) = 9; the check digit remains the same.
+ *
+ */
+
+/* where the digit set begins, and how many of them are in the table */
+const unsigned ISMN_index[10][2] = {
+	{0, 5},
+	{5, 0},
+	{5, 0},
+	{5, 0},
+	{5, 0},
+	{5, 0},
+	{5, 0},
+	{5, 0},
+	{5, 0},
+	{5, 0},
+};
+const char *ISMN_range[][2] = {
+	{"0-000", "0-099"},
+	{"0-1000", "0-3999"},
+	{"0-40000", "0-69999"},
+	{"0-700000", "0-899999"},
+	{"0-9000000", "0-9999999"},
+	{NULL, NULL}
+};
diff --git a/contrib/isn/ISSN.h b/contrib/isn/ISSN.h
new file mode 100644
index 0000000..585f0e2
--- /dev/null
+++ b/contrib/isn/ISSN.h
@@ -0,0 +1,49 @@
+/*
+ * ISSN.h
+ *	  PostgreSQL type definitions for ISNs (ISBN, ISMN, ISSN, EAN13, UPC)
+ *
+ * Information recompiled by Kronuz on November 12, 2004
+ * http://www.issn.org/
+ *
+ * IDENTIFICATION
+ *	  contrib/isn/ISSN.h
+ *
+ * 1144-875X <=> 1144875(X) <=> 1144875 <=> (977)1144875 <=> 9771144875(00) <=> 977114487500(7) <=> 977-1144-875-00-7
+ *
+ *
+ * ISSN			1	1	4	 4	  8    7	5
+ * Weight		8	7	6	 5	  4    3	2
+ * Product		8 + 7 + 24 + 20 + 32 + 21 + 10 = 122
+ *				122 / 11 = 11 remainder 1
+ * Check digit	11 - 1 = 10 = X
+ * => 1144-875X
+ *
+ * ISSN			9	7	 7	 1	 1	 4	  4   8    7   5	0	0
+ * Weight		1	3	 1	 3	 1	 3	  1   3    1   3	1	3
+ * Product		9 + 21 + 7 + 3 + 1 + 12 + 4 + 24 + 7 + 15 + 0 + 0 = 103
+ *				103 / 10 = 10 remainder 3
+ * Check digit	10 - 3 = 7
+ * => 977-1144875-00-7 ??  <- supplemental number (number of the week, month, etc.)
+ *				  ^^ 00 for non-daily publications (01=Monday, 02=Tuesday, ...)
+ *
+ * The hyphenation is always in after the four digits of the ISSN code.
+ *
+ */
+
+/* where the digit set begins, and how many of them are in the table */
+const unsigned ISSN_index[10][2] = {
+	{0, 1},
+	{0, 1},
+	{0, 1},
+	{0, 1},
+	{0, 1},
+	{0, 1},
+	{0, 1},
+	{0, 1},
+	{0, 1},
+	{0, 1},
+};
+const char *ISSN_range[][2] = {
+	{"0000-000", "9999-999"},
+	{NULL, NULL}
+};
diff --git a/contrib/isn/Makefile b/contrib/isn/Makefile
new file mode 100644
index 0000000..1037506
--- /dev/null
+++ b/contrib/isn/Makefile
@@ -0,0 +1,24 @@
+# contrib/isn/Makefile
+
+MODULES = isn
+
+EXTENSION = isn
+DATA = isn--1.1.sql isn--1.1--1.2.sql \
+	isn--1.0--1.1.sql
+PGFILEDESC = "isn - data types for international product numbering standards"
+
+# the other .h files are data tables, we don't install those
+HEADERS_isn = isn.h
+
+REGRESS = isn
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = contrib/isn
+top_builddir = ../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
diff --git a/contrib/isn/UPC.h b/contrib/isn/UPC.h
new file mode 100644
index 0000000..b95473e
--- /dev/null
+++ b/contrib/isn/UPC.h
@@ -0,0 +1,28 @@
+/*
+ * ISSN.h
+ *	  PostgreSQL type definitions for ISNs (ISBN, ISMN, ISSN, EAN13, UPC)
+ *
+ * No information available for UPC prefixes
+ *
+ *
+ * IDENTIFICATION
+ *	  contrib/isn/UPC.h
+ *
+ */
+
+/* where the digit set begins, and how many of them are in the table */
+const unsigned UPC_index[10][2] = {
+	{0, 0},
+	{0, 0},
+	{0, 0},
+	{0, 0},
+	{0, 0},
+	{0, 0},
+	{0, 0},
+	{0, 0},
+	{0, 0},
+	{0, 0},
+};
+const char *UPC_range[][2] = {
+	{NULL, NULL}
+};
diff --git a/contrib/isn/expected/isn.out b/contrib/isn/expected/isn.out
new file mode 100644
index 0000000..18fe37a
--- /dev/null
+++ b/contrib/isn/expected/isn.out
@@ -0,0 +1,266 @@
+--
+-- Test ISN extension
+--
+CREATE EXTENSION isn;
+-- Check whether any of our opclasses fail amvalidate
+-- ... they will, because of missing cross-type operators
+SELECT amname, opcname
+FROM (SELECT amname, opcname, opc.oid
+      FROM pg_opclass opc LEFT JOIN pg_am am ON am.oid = opcmethod
+      WHERE opc.oid >= 16384
+      ORDER BY 1, 2 OFFSET 0) ss
+WHERE NOT amvalidate(oid);
+INFO:  operator family "isn_ops" of access method btree is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method btree is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method btree is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method btree is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method btree is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method btree is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method btree is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method btree is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method hash is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method hash is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method hash is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method hash is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method hash is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method hash is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method hash is missing cross-type operator(s)
+INFO:  operator family "isn_ops" of access method hash is missing cross-type operator(s)
+ amname |  opcname   
+--------+------------
+ btree  | ean13_ops
+ btree  | isbn13_ops
+ btree  | isbn_ops
+ btree  | ismn13_ops
+ btree  | ismn_ops
+ btree  | issn13_ops
+ btree  | issn_ops
+ btree  | upc_ops
+ hash   | ean13_ops
+ hash   | isbn13_ops
+ hash   | isbn_ops
+ hash   | ismn13_ops
+ hash   | ismn_ops
+ hash   | issn13_ops
+ hash   | issn_ops
+ hash   | upc_ops
+(16 rows)
+
+--
+-- test valid conversions
+--
+SELECT '9780123456786'::EAN13, -- old book
+       '9790123456785'::EAN13, -- music
+       '9791234567896'::EAN13, -- new book
+       '9771234567898'::EAN13, -- serial
+       '0123456789012'::EAN13, -- upc
+       '1234567890128'::EAN13;
+       ean13       |       ean13       |      ean13      |       ean13       |      ean13      |      ean13      
+-------------------+-------------------+-----------------+-------------------+-----------------+-----------------
+ 978-0-12-345678-6 | 979-0-1234-5678-5 | 979-123456789-6 | 977-1234-567-89-8 | 012-345678901-2 | 123-456789012-8
+(1 row)
+
+SELECT '9780123456786'::ISBN,
+       '123456789X'::ISBN,
+       '9780123456786'::ISBN13::ISBN,
+       '9780123456786'::EAN13::ISBN;
+     isbn      |     isbn      |     isbn      |     isbn      
+---------------+---------------+---------------+---------------
+ 0-12-345678-9 | 1-234-56789-X | 0-12-345678-9 | 0-12-345678-9
+(1 row)
+
+SELECT -- new books, shown as ISBN13 even for ISBN...
+       '9791234567896'::ISBN,
+       '9791234567896'::ISBN13::ISBN,
+       '9791234567896'::EAN13::ISBN;
+      isbn       |      isbn       |      isbn       
+-----------------+-----------------+-----------------
+ 979-123456789-6 | 979-123456789-6 | 979-123456789-6
+(1 row)
+
+SELECT '9780123456786'::ISBN13,
+       '123456789X'::ISBN13,
+       '9791234567896'::ISBN13,
+       '9791234567896'::EAN13::ISBN13;
+      isbn13       |      isbn13       |     isbn13      |     isbn13      
+-------------------+-------------------+-----------------+-----------------
+ 978-0-12-345678-6 | 978-1-234-56789-7 | 979-123456789-6 | 979-123456789-6
+(1 row)
+
+SELECT '9790123456785'::ISMN,
+       '9790123456785'::EAN13::ISMN,
+       'M123456785'::ISMN,
+       'M-1234-5678-5'::ISMN;
+     ismn      |     ismn      |     ismn      |     ismn      
+---------------+---------------+---------------+---------------
+ M-1234-5678-5 | M-1234-5678-5 | M-1234-5678-5 | M-1234-5678-5
+(1 row)
+
+SELECT '9790123456785'::ISMN13,
+       'M123456785'::ISMN13,
+       'M-1234-5678-5'::ISMN13;
+      ismn13       |      ismn13       |      ismn13       
+-------------------+-------------------+-------------------
+ 979-0-1234-5678-5 | 979-0-1234-5678-5 | 979-0-1234-5678-5
+(1 row)
+
+SELECT '9771234567003'::ISSN,
+       '12345679'::ISSN;
+   issn    |   issn    
+-----------+-----------
+ 1234-5679 | 1234-5679
+(1 row)
+
+SELECT '9771234567003'::ISSN13,
+       '12345679'::ISSN13,
+       '9771234567898'::ISSN13,
+       '9771234567898'::EAN13::ISSN13;
+      issn13       |      issn13       |      issn13       |      issn13       
+-------------------+-------------------+-------------------+-------------------
+ 977-1234-567-00-3 | 977-1234-567-00-3 | 977-1234-567-89-8 | 977-1234-567-89-8
+(1 row)
+
+SELECT '0123456789012'::UPC,
+       '0123456789012'::EAN13::UPC;
+     upc      |     upc      
+--------------+--------------
+ 123456789012 | 123456789012
+(1 row)
+
+--
+-- test invalid checksums
+--
+SELECT '1234567890'::ISBN;
+ERROR:  invalid check digit for ISBN number: "1234567890", should be X
+LINE 1: SELECT '1234567890'::ISBN;
+               ^
+SELECT 'M123456780'::ISMN;
+ERROR:  invalid check digit for ISMN number: "M123456780", should be 5
+LINE 1: SELECT 'M123456780'::ISMN;
+               ^
+SELECT '12345670'::ISSN;
+ERROR:  invalid check digit for ISSN number: "12345670", should be 9
+LINE 1: SELECT '12345670'::ISSN;
+               ^
+SELECT '9780123456780'::ISBN;
+ERROR:  invalid check digit for ISBN number: "9780123456780", should be 6
+LINE 1: SELECT '9780123456780'::ISBN;
+               ^
+SELECT '9791234567890'::ISBN13;
+ERROR:  invalid check digit for ISBN number: "9791234567890", should be 6
+LINE 1: SELECT '9791234567890'::ISBN13;
+               ^
+SELECT '0123456789010'::UPC;
+ERROR:  invalid check digit for UPC number: "0123456789010", should be 2
+LINE 1: SELECT '0123456789010'::UPC;
+               ^
+SELECT '1234567890120'::EAN13;
+ERROR:  invalid check digit for EAN13 number: "1234567890120", should be 8
+LINE 1: SELECT '1234567890120'::EAN13;
+               ^
+--
+-- test invalid conversions
+--
+SELECT '9790123456785'::ISBN; -- not a book
+ERROR:  cannot cast ISMN to ISBN for number: "9790123456785"
+LINE 1: SELECT '9790123456785'::ISBN;
+               ^
+SELECT '9771234567898'::ISBN; -- not a book
+ERROR:  cannot cast ISSN to ISBN for number: "9771234567898"
+LINE 1: SELECT '9771234567898'::ISBN;
+               ^
+SELECT '0123456789012'::ISBN; -- not a book
+ERROR:  cannot cast UPC to ISBN for number: "0123456789012"
+LINE 1: SELECT '0123456789012'::ISBN;
+               ^
+SELECT '9790123456785'::ISBN13; -- not a book
+ERROR:  cannot cast ISMN to ISBN for number: "9790123456785"
+LINE 1: SELECT '9790123456785'::ISBN13;
+               ^
+SELECT '9771234567898'::ISBN13; -- not a book
+ERROR:  cannot cast ISSN to ISBN for number: "9771234567898"
+LINE 1: SELECT '9771234567898'::ISBN13;
+               ^
+SELECT '0123456789012'::ISBN13; -- not a book
+ERROR:  cannot cast UPC to ISBN for number: "0123456789012"
+LINE 1: SELECT '0123456789012'::ISBN13;
+               ^
+SELECT '9780123456786'::ISMN; -- not music
+ERROR:  cannot cast ISBN to ISMN for number: "9780123456786"
+LINE 1: SELECT '9780123456786'::ISMN;
+               ^
+SELECT '9771234567898'::ISMN; -- not music
+ERROR:  cannot cast ISSN to ISMN for number: "9771234567898"
+LINE 1: SELECT '9771234567898'::ISMN;
+               ^
+SELECT '9791234567896'::ISMN; -- not music
+ERROR:  cannot cast ISBN to ISMN for number: "9791234567896"
+LINE 1: SELECT '9791234567896'::ISMN;
+               ^
+SELECT '0123456789012'::ISMN; -- not music
+ERROR:  cannot cast UPC to ISMN for number: "0123456789012"
+LINE 1: SELECT '0123456789012'::ISMN;
+               ^
+SELECT '9780123456786'::ISSN; -- not serial
+ERROR:  cannot cast ISBN to ISSN for number: "9780123456786"
+LINE 1: SELECT '9780123456786'::ISSN;
+               ^
+SELECT '9790123456785'::ISSN; -- not serial
+ERROR:  cannot cast ISMN to ISSN for number: "9790123456785"
+LINE 1: SELECT '9790123456785'::ISSN;
+               ^
+SELECT '9791234567896'::ISSN; -- not serial
+ERROR:  cannot cast ISBN to ISSN for number: "9791234567896"
+LINE 1: SELECT '9791234567896'::ISSN;
+               ^
+SELECT '0123456789012'::ISSN; -- not serial
+ERROR:  cannot cast UPC to ISSN for number: "0123456789012"
+LINE 1: SELECT '0123456789012'::ISSN;
+               ^
+SELECT '9780123456786'::UPC; -- not a product
+ERROR:  cannot cast ISBN to UPC for number: "9780123456786"
+LINE 1: SELECT '9780123456786'::UPC;
+               ^
+SELECT '9771234567898'::UPC; -- not a product
+ERROR:  cannot cast ISSN to UPC for number: "9771234567898"
+LINE 1: SELECT '9771234567898'::UPC;
+               ^
+SELECT '9790123456785'::UPC; -- not a product
+ERROR:  cannot cast ISMN to UPC for number: "9790123456785"
+LINE 1: SELECT '9790123456785'::UPC;
+               ^
+SELECT '9791234567896'::UPC; -- not a product
+ERROR:  cannot cast ISBN to UPC for number: "9791234567896"
+LINE 1: SELECT '9791234567896'::UPC;
+               ^
+SELECT 'postgresql...'::EAN13;
+ERROR:  invalid input syntax for EAN13 number: "postgresql..."
+LINE 1: SELECT 'postgresql...'::EAN13;
+               ^
+SELECT 'postgresql...'::ISBN;
+ERROR:  invalid input syntax for ISBN number: "postgresql..."
+LINE 1: SELECT 'postgresql...'::ISBN;
+               ^
+SELECT 9780123456786::EAN13;
+ERROR:  cannot cast type bigint to ean13
+LINE 1: SELECT 9780123456786::EAN13;
+                            ^
+SELECT 9780123456786::ISBN;
+ERROR:  cannot cast type bigint to isbn
+LINE 1: SELECT 9780123456786::ISBN;
+                            ^
+--
+-- test some comparisons, must yield true
+--
+SELECT '12345679'::ISSN = '9771234567003'::EAN13 AS "ok",
+       'M-1234-5678-5'::ISMN = '9790123456785'::EAN13 AS "ok",
+       '9791234567896'::EAN13 != '123456789X'::ISBN AS "nope";
+ ok | ok | nope 
+----+----+------
+ t  | t  | t
+(1 row)
+
+--
+-- cleanup
+--
+DROP EXTENSION isn;
diff --git a/contrib/isn/isn--1.0--1.1.sql b/contrib/isn/isn--1.0--1.1.sql
new file mode 100644
index 0000000..6f1ccb0
--- /dev/null
+++ b/contrib/isn/isn--1.0--1.1.sql
@@ -0,0 +1,250 @@
+/* contrib/isn/isn--1.0--1.1.sql */
+
+-- complain if script is sourced in psql, rather than via ALTER EXTENSION
+\echo Use "ALTER EXTENSION isn UPDATE TO '1.1'" to load this file. \quit
+
+ALTER FUNCTION ean13_in(cstring) PARALLEL SAFE;
+ALTER FUNCTION ean13_out(ean13) PARALLEL SAFE;
+ALTER FUNCTION isbn13_in(cstring) PARALLEL SAFE;
+ALTER FUNCTION ean13_out(isbn13) PARALLEL SAFE;
+ALTER FUNCTION ismn13_in(cstring) PARALLEL SAFE;
+ALTER FUNCTION ean13_out(ismn13) PARALLEL SAFE;
+ALTER FUNCTION issn13_in(cstring) PARALLEL SAFE;
+ALTER FUNCTION ean13_out(issn13) PARALLEL SAFE;
+ALTER FUNCTION isbn_in(cstring) PARALLEL SAFE;
+ALTER FUNCTION isn_out(isbn) PARALLEL SAFE;
+ALTER FUNCTION ismn_in(cstring) PARALLEL SAFE;
+ALTER FUNCTION isn_out(ismn) PARALLEL SAFE;
+ALTER FUNCTION issn_in(cstring) PARALLEL SAFE;
+ALTER FUNCTION isn_out(issn) PARALLEL SAFE;
+ALTER FUNCTION upc_in(cstring) PARALLEL SAFE;
+ALTER FUNCTION isn_out(upc) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ean13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnle(ean13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isneq(ean13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnge(ean13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isngt(ean13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnne(ean13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ean13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isnle(ean13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isneq(ean13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isnge(ean13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isngt(ean13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isnne(ean13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ean13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isnle(ean13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isneq(ean13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isnge(ean13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isngt(ean13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isnne(ean13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ean13, issn13) PARALLEL SAFE;
+ALTER FUNCTION isnle(ean13, issn13) PARALLEL SAFE;
+ALTER FUNCTION isneq(ean13, issn13) PARALLEL SAFE;
+ALTER FUNCTION isnge(ean13, issn13) PARALLEL SAFE;
+ALTER FUNCTION isngt(ean13, issn13) PARALLEL SAFE;
+ALTER FUNCTION isnne(ean13, issn13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ean13, isbn) PARALLEL SAFE;
+ALTER FUNCTION isnle(ean13, isbn) PARALLEL SAFE;
+ALTER FUNCTION isneq(ean13, isbn) PARALLEL SAFE;
+ALTER FUNCTION isnge(ean13, isbn) PARALLEL SAFE;
+ALTER FUNCTION isngt(ean13, isbn) PARALLEL SAFE;
+ALTER FUNCTION isnne(ean13, isbn) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ean13, ismn) PARALLEL SAFE;
+ALTER FUNCTION isnle(ean13, ismn) PARALLEL SAFE;
+ALTER FUNCTION isneq(ean13, ismn) PARALLEL SAFE;
+ALTER FUNCTION isnge(ean13, ismn) PARALLEL SAFE;
+ALTER FUNCTION isngt(ean13, ismn) PARALLEL SAFE;
+ALTER FUNCTION isnne(ean13, ismn) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ean13, issn) PARALLEL SAFE;
+ALTER FUNCTION isnle(ean13, issn) PARALLEL SAFE;
+ALTER FUNCTION isneq(ean13, issn) PARALLEL SAFE;
+ALTER FUNCTION isnge(ean13, issn) PARALLEL SAFE;
+ALTER FUNCTION isngt(ean13, issn) PARALLEL SAFE;
+ALTER FUNCTION isnne(ean13, issn) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ean13, upc) PARALLEL SAFE;
+ALTER FUNCTION isnle(ean13, upc) PARALLEL SAFE;
+ALTER FUNCTION isneq(ean13, upc) PARALLEL SAFE;
+ALTER FUNCTION isnge(ean13, upc) PARALLEL SAFE;
+ALTER FUNCTION isngt(ean13, upc) PARALLEL SAFE;
+ALTER FUNCTION isnne(ean13, upc) PARALLEL SAFE;
+ALTER FUNCTION isnlt(isbn13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isnle(isbn13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isneq(isbn13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isnge(isbn13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isngt(isbn13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isnne(isbn13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(isbn13, isbn) PARALLEL SAFE;
+ALTER FUNCTION isnle(isbn13, isbn) PARALLEL SAFE;
+ALTER FUNCTION isneq(isbn13, isbn) PARALLEL SAFE;
+ALTER FUNCTION isnge(isbn13, isbn) PARALLEL SAFE;
+ALTER FUNCTION isngt(isbn13, isbn) PARALLEL SAFE;
+ALTER FUNCTION isnne(isbn13, isbn) PARALLEL SAFE;
+ALTER FUNCTION isnlt(isbn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnle(isbn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isneq(isbn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnge(isbn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isngt(isbn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnne(isbn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(isbn, isbn) PARALLEL SAFE;
+ALTER FUNCTION isnle(isbn, isbn) PARALLEL SAFE;
+ALTER FUNCTION isneq(isbn, isbn) PARALLEL SAFE;
+ALTER FUNCTION isnge(isbn, isbn) PARALLEL SAFE;
+ALTER FUNCTION isngt(isbn, isbn) PARALLEL SAFE;
+ALTER FUNCTION isnne(isbn, isbn) PARALLEL SAFE;
+ALTER FUNCTION isnlt(isbn, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isnle(isbn, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isneq(isbn, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isnge(isbn, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isngt(isbn, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isnne(isbn, isbn13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(isbn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnle(isbn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isneq(isbn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnge(isbn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isngt(isbn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnne(isbn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ismn13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isnle(ismn13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isneq(ismn13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isnge(ismn13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isngt(ismn13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isnne(ismn13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ismn13, ismn) PARALLEL SAFE;
+ALTER FUNCTION isnle(ismn13, ismn) PARALLEL SAFE;
+ALTER FUNCTION isneq(ismn13, ismn) PARALLEL SAFE;
+ALTER FUNCTION isnge(ismn13, ismn) PARALLEL SAFE;
+ALTER FUNCTION isngt(ismn13, ismn) PARALLEL SAFE;
+ALTER FUNCTION isnne(ismn13, ismn) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ismn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnle(ismn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isneq(ismn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnge(ismn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isngt(ismn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnne(ismn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ismn, ismn) PARALLEL SAFE;
+ALTER FUNCTION isnle(ismn, ismn) PARALLEL SAFE;
+ALTER FUNCTION isneq(ismn, ismn) PARALLEL SAFE;
+ALTER FUNCTION isnge(ismn, ismn) PARALLEL SAFE;
+ALTER FUNCTION isngt(ismn, ismn) PARALLEL SAFE;
+ALTER FUNCTION isnne(ismn, ismn) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ismn, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isnle(ismn, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isneq(ismn, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isnge(ismn, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isngt(ismn, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isnne(ismn, ismn13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(ismn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnle(ismn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isneq(ismn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnge(ismn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isngt(ismn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnne(ismn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(issn13, issn13) PARALLEL SAFE;
+ALTER FUNCTION isnle(issn13, issn13) PARALLEL SAFE;
+ALTER FUNCTION isneq(issn13, issn13) PARALLEL SAFE;
+ALTER FUNCTION isnge(issn13, issn13) PARALLEL SAFE;
+ALTER FUNCTION isngt(issn13, issn13) PARALLEL SAFE;
+ALTER FUNCTION isnne(issn13, issn13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(issn13, issn) PARALLEL SAFE;
+ALTER FUNCTION isnle(issn13, issn) PARALLEL SAFE;
+ALTER FUNCTION isneq(issn13, issn) PARALLEL SAFE;
+ALTER FUNCTION isnge(issn13, issn) PARALLEL SAFE;
+ALTER FUNCTION isngt(issn13, issn) PARALLEL SAFE;
+ALTER FUNCTION isnne(issn13, issn) PARALLEL SAFE;
+ALTER FUNCTION isnlt(issn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnle(issn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isneq(issn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnge(issn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isngt(issn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnne(issn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(issn, issn) PARALLEL SAFE;
+ALTER FUNCTION isnle(issn, issn) PARALLEL SAFE;
+ALTER FUNCTION isneq(issn, issn) PARALLEL SAFE;
+ALTER FUNCTION isnge(issn, issn) PARALLEL SAFE;
+ALTER FUNCTION isngt(issn, issn) PARALLEL SAFE;
+ALTER FUNCTION isnne(issn, issn) PARALLEL SAFE;
+ALTER FUNCTION isnlt(issn, issn13) PARALLEL SAFE;
+ALTER FUNCTION isnle(issn, issn13) PARALLEL SAFE;
+ALTER FUNCTION isneq(issn, issn13) PARALLEL SAFE;
+ALTER FUNCTION isnge(issn, issn13) PARALLEL SAFE;
+ALTER FUNCTION isngt(issn, issn13) PARALLEL SAFE;
+ALTER FUNCTION isnne(issn, issn13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(issn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnle(issn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isneq(issn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnge(issn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isngt(issn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnne(issn, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnlt(upc, upc) PARALLEL SAFE;
+ALTER FUNCTION isnle(upc, upc) PARALLEL SAFE;
+ALTER FUNCTION isneq(upc, upc) PARALLEL SAFE;
+ALTER FUNCTION isnge(upc, upc) PARALLEL SAFE;
+ALTER FUNCTION isngt(upc, upc) PARALLEL SAFE;
+ALTER FUNCTION isnne(upc, upc) PARALLEL SAFE;
+ALTER FUNCTION isnlt(upc, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnle(upc, ean13) PARALLEL SAFE;
+ALTER FUNCTION isneq(upc, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnge(upc, ean13) PARALLEL SAFE;
+ALTER FUNCTION isngt(upc, ean13) PARALLEL SAFE;
+ALTER FUNCTION isnne(upc, ean13) PARALLEL SAFE;
+ALTER FUNCTION btean13cmp(ean13, ean13) PARALLEL SAFE;
+ALTER FUNCTION hashean13(ean13) PARALLEL SAFE;
+ALTER FUNCTION btean13cmp(ean13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION btean13cmp(ean13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION btean13cmp(ean13, issn13) PARALLEL SAFE;
+ALTER FUNCTION btean13cmp(ean13, isbn) PARALLEL SAFE;
+ALTER FUNCTION btean13cmp(ean13, ismn) PARALLEL SAFE;
+ALTER FUNCTION btean13cmp(ean13, issn) PARALLEL SAFE;
+ALTER FUNCTION btean13cmp(ean13, upc) PARALLEL SAFE;
+ALTER FUNCTION btisbn13cmp(isbn13, isbn13) PARALLEL SAFE;
+ALTER FUNCTION hashisbn13(isbn13) PARALLEL SAFE;
+ALTER FUNCTION btisbn13cmp(isbn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION btisbn13cmp(isbn13, isbn) PARALLEL SAFE;
+ALTER FUNCTION btisbncmp(isbn, isbn) PARALLEL SAFE;
+ALTER FUNCTION hashisbn(isbn) PARALLEL SAFE;
+ALTER FUNCTION btisbncmp(isbn, ean13) PARALLEL SAFE;
+ALTER FUNCTION btisbncmp(isbn, isbn13) PARALLEL SAFE;
+ALTER FUNCTION btismn13cmp(ismn13, ismn13) PARALLEL SAFE;
+ALTER FUNCTION hashismn13(ismn13) PARALLEL SAFE;
+ALTER FUNCTION btismn13cmp(ismn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION btismn13cmp(ismn13, ismn) PARALLEL SAFE;
+ALTER FUNCTION btismncmp(ismn, ismn) PARALLEL SAFE;
+ALTER FUNCTION hashismn(ismn) PARALLEL SAFE;
+ALTER FUNCTION btismncmp(ismn, ean13) PARALLEL SAFE;
+ALTER FUNCTION btismncmp(ismn, ismn13) PARALLEL SAFE;
+ALTER FUNCTION btissn13cmp(issn13, issn13) PARALLEL SAFE;
+ALTER FUNCTION hashissn13(issn13) PARALLEL SAFE;
+ALTER FUNCTION btissn13cmp(issn13, ean13) PARALLEL SAFE;
+ALTER FUNCTION btissn13cmp(issn13, issn) PARALLEL SAFE;
+ALTER FUNCTION btissncmp(issn, issn) PARALLEL SAFE;
+ALTER FUNCTION hashissn(issn) PARALLEL SAFE;
+ALTER FUNCTION btissncmp(issn, ean13) PARALLEL SAFE;
+ALTER FUNCTION btissncmp(issn, issn13) PARALLEL SAFE;
+ALTER FUNCTION btupccmp(upc, upc) PARALLEL SAFE;
+ALTER FUNCTION hashupc(upc) PARALLEL SAFE;
+ALTER FUNCTION btupccmp(upc, ean13) PARALLEL SAFE;
+ALTER FUNCTION isbn13(ean13) PARALLEL SAFE;
+ALTER FUNCTION ismn13(ean13) PARALLEL SAFE;
+ALTER FUNCTION issn13(ean13) PARALLEL SAFE;
+ALTER FUNCTION isbn(ean13) PARALLEL SAFE;
+ALTER FUNCTION ismn(ean13) PARALLEL SAFE;
+ALTER FUNCTION issn(ean13) PARALLEL SAFE;
+ALTER FUNCTION upc(ean13) PARALLEL SAFE;
+ALTER FUNCTION make_valid(ean13) PARALLEL SAFE;
+ALTER FUNCTION make_valid(isbn13) PARALLEL SAFE;
+ALTER FUNCTION make_valid(ismn13) PARALLEL SAFE;
+ALTER FUNCTION make_valid(issn13) PARALLEL SAFE;
+ALTER FUNCTION make_valid(isbn) PARALLEL SAFE;
+ALTER FUNCTION make_valid(ismn) PARALLEL SAFE;
+ALTER FUNCTION make_valid(issn) PARALLEL SAFE;
+ALTER FUNCTION make_valid(upc) PARALLEL SAFE;
+ALTER FUNCTION is_valid(ean13) PARALLEL SAFE;
+ALTER FUNCTION is_valid(isbn13) PARALLEL SAFE;
+ALTER FUNCTION is_valid(ismn13) PARALLEL SAFE;
+ALTER FUNCTION is_valid(issn13) PARALLEL SAFE;
+ALTER FUNCTION is_valid(isbn) PARALLEL SAFE;
+ALTER FUNCTION is_valid(ismn) PARALLEL SAFE;
+ALTER FUNCTION is_valid(issn) PARALLEL SAFE;
+ALTER FUNCTION is_valid(upc) PARALLEL SAFE;
+ALTER FUNCTION isn_weak(boolean) PARALLEL RESTRICTED;
+ALTER FUNCTION isn_weak() PARALLEL RESTRICTED;
diff --git a/contrib/isn/isn--1.1--1.2.sql b/contrib/isn/isn--1.1--1.2.sql
new file mode 100644
index 0000000..d626a5f
--- /dev/null
+++ b/contrib/isn/isn--1.1--1.2.sql
@@ -0,0 +1,228 @@
+/* contrib/isn/isn--1.1--1.2.sql */
+
+-- complain if script is sourced in psql, rather than via ALTER EXTENSION
+\echo Use "ALTER EXTENSION isn UPDATE TO '1.2'" to load this file. \quit
+
+ALTER OPERATOR <= (ean13, ean13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ean13, ean13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (ean13, isbn13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ean13, isbn13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (isbn13, ean13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (isbn13, ean13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (ean13, ismn13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ean13, ismn13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (ismn13, ean13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ismn13, ean13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (ean13, issn13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ean13, issn13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (ean13, isbn) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ean13, isbn) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (ean13, ismn) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ean13, ismn) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (ean13, issn) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ean13, issn) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (ean13, upc) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ean13, upc) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (isbn13, isbn13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (isbn13, isbn13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (isbn13, isbn) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (isbn13, isbn) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (isbn, isbn) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (isbn, isbn) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (isbn, isbn13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (isbn, isbn13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (isbn, ean13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (isbn, ean13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (ismn13, ismn13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ismn13, ismn13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (ismn13, ismn) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ismn13, ismn) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (ismn, ismn) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ismn, ismn) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (ismn, ismn13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ismn, ismn13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (ismn, ean13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (ismn, ean13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (issn13, issn13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (issn13, issn13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (issn13, issn) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (issn13, issn) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (issn13, ean13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (issn13, ean13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (issn, issn) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (issn, issn) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (issn, issn13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (issn, issn13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (issn, ean13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (issn, ean13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (upc, upc) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (upc, upc) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
+
+ALTER OPERATOR <= (upc, ean13) SET (
+	RESTRICT = scalarlesel,
+	JOIN = scalarlejoinsel);
+
+ALTER OPERATOR >= (upc, ean13) SET (
+	RESTRICT = scalargesel,
+	JOIN = scalargejoinsel);
diff --git a/contrib/isn/isn--1.1.sql b/contrib/isn/isn--1.1.sql
new file mode 100644
index 0000000..5206961
--- /dev/null
+++ b/contrib/isn/isn--1.1.sql
@@ -0,0 +1,3434 @@
+/* contrib/isn/isn--1.1.sql */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION isn" to load this file. \quit
+
+-- Example:
+--   create table test ( id isbn );
+--   insert into test values('978-0-393-04002-9');
+--
+--   select isbn('978-0-393-04002-9');
+--   select isbn13('0-901690-54-6');
+--
+
+--
+--	Input and output functions and data types:
+--
+---------------------------------------------------
+CREATE FUNCTION ean13_in(cstring)
+	RETURNS ean13
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION ean13_out(ean13)
+	RETURNS cstring
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE TYPE ean13 (
+	INPUT = ean13_in,
+	OUTPUT = ean13_out,
+	LIKE = pg_catalog.int8
+);
+COMMENT ON TYPE ean13
+	IS 'International European Article Number (EAN13)';
+
+CREATE FUNCTION isbn13_in(cstring)
+	RETURNS isbn13
+	AS 'MODULE_PATHNAME', 'isbn_in'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION ean13_out(isbn13)
+	RETURNS cstring
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE TYPE isbn13 (
+	INPUT = isbn13_in,
+	OUTPUT = ean13_out,
+	LIKE = pg_catalog.int8
+);
+COMMENT ON TYPE isbn13
+	IS 'International Standard Book Number 13 (ISBN13)';
+
+CREATE FUNCTION ismn13_in(cstring)
+	RETURNS ismn13
+	AS 'MODULE_PATHNAME', 'ismn_in'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION ean13_out(ismn13)
+	RETURNS cstring
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE TYPE ismn13 (
+	INPUT = ismn13_in,
+	OUTPUT = ean13_out,
+	LIKE = pg_catalog.int8
+);
+COMMENT ON TYPE ismn13
+	IS 'International Standard Music Number 13 (ISMN13)';
+
+CREATE FUNCTION issn13_in(cstring)
+	RETURNS issn13
+	AS 'MODULE_PATHNAME', 'issn_in'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION ean13_out(issn13)
+	RETURNS cstring
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE TYPE issn13 (
+	INPUT = issn13_in,
+	OUTPUT = ean13_out,
+	LIKE = pg_catalog.int8
+);
+COMMENT ON TYPE issn13
+	IS 'International Standard Serial Number 13 (ISSN13)';
+
+-- Short format:
+
+CREATE FUNCTION isbn_in(cstring)
+	RETURNS isbn
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isn_out(isbn)
+	RETURNS cstring
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE TYPE isbn (
+	INPUT = isbn_in,
+	OUTPUT = isn_out,
+	LIKE = pg_catalog.int8
+);
+COMMENT ON TYPE isbn
+	IS 'International Standard Book Number (ISBN)';
+
+CREATE FUNCTION ismn_in(cstring)
+	RETURNS ismn
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isn_out(ismn)
+	RETURNS cstring
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE TYPE ismn (
+	INPUT = ismn_in,
+	OUTPUT = isn_out,
+	LIKE = pg_catalog.int8
+);
+COMMENT ON TYPE ismn
+	IS 'International Standard Music Number (ISMN)';
+
+CREATE FUNCTION issn_in(cstring)
+	RETURNS issn
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isn_out(issn)
+	RETURNS cstring
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE TYPE issn (
+	INPUT = issn_in,
+	OUTPUT = isn_out,
+	LIKE = pg_catalog.int8
+);
+COMMENT ON TYPE issn
+	IS 'International Standard Serial Number (ISSN)';
+
+CREATE FUNCTION upc_in(cstring)
+	RETURNS upc
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isn_out(upc)
+	RETURNS cstring
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE TYPE upc (
+	INPUT = upc_in,
+	OUTPUT = isn_out,
+	LIKE = pg_catalog.int8
+);
+COMMENT ON TYPE upc
+	IS 'Universal Product Code (UPC)';
+
+--
+-- Operator functions:
+--
+---------------------------------------------------
+-- EAN13:
+CREATE FUNCTION isnlt(ean13, ean13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ean13, ean13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ean13, ean13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ean13, ean13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ean13, ean13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ean13, ean13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(ean13, isbn13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ean13, isbn13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ean13, isbn13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ean13, isbn13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ean13, isbn13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ean13, isbn13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(ean13, ismn13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ean13, ismn13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ean13, ismn13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ean13, ismn13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ean13, ismn13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ean13, ismn13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(ean13, issn13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ean13, issn13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ean13, issn13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ean13, issn13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ean13, issn13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ean13, issn13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(ean13, isbn)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ean13, isbn)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ean13, isbn)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ean13, isbn)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ean13, isbn)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ean13, isbn)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(ean13, ismn)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ean13, ismn)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ean13, ismn)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ean13, ismn)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ean13, ismn)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ean13, ismn)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(ean13, issn)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ean13, issn)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ean13, issn)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ean13, issn)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ean13, issn)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ean13, issn)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(ean13, upc)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ean13, upc)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ean13, upc)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ean13, upc)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ean13, upc)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ean13, upc)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+---------------------------------------------------
+-- ISBN13:
+CREATE FUNCTION isnlt(isbn13, isbn13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(isbn13, isbn13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(isbn13, isbn13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(isbn13, isbn13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(isbn13, isbn13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(isbn13, isbn13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(isbn13, isbn)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(isbn13, isbn)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(isbn13, isbn)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(isbn13, isbn)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(isbn13, isbn)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(isbn13, isbn)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(isbn13, ean13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(isbn13, ean13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(isbn13, ean13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(isbn13, ean13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(isbn13, ean13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(isbn13, ean13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+---------------------------------------------------
+-- ISBN:
+CREATE FUNCTION isnlt(isbn, isbn)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(isbn, isbn)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(isbn, isbn)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(isbn, isbn)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(isbn, isbn)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(isbn, isbn)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(isbn, isbn13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(isbn, isbn13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(isbn, isbn13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(isbn, isbn13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(isbn, isbn13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(isbn, isbn13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(isbn, ean13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(isbn, ean13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(isbn, ean13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(isbn, ean13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(isbn, ean13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(isbn, ean13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+---------------------------------------------------
+-- ISMN13:
+CREATE FUNCTION isnlt(ismn13, ismn13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ismn13, ismn13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ismn13, ismn13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ismn13, ismn13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ismn13, ismn13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ismn13, ismn13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(ismn13, ismn)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ismn13, ismn)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ismn13, ismn)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ismn13, ismn)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ismn13, ismn)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ismn13, ismn)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(ismn13, ean13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ismn13, ean13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ismn13, ean13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ismn13, ean13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ismn13, ean13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ismn13, ean13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+---------------------------------------------------
+-- ISMN:
+CREATE FUNCTION isnlt(ismn, ismn)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ismn, ismn)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ismn, ismn)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ismn, ismn)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ismn, ismn)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ismn, ismn)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(ismn, ismn13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ismn, ismn13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ismn, ismn13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ismn, ismn13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ismn, ismn13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ismn, ismn13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(ismn, ean13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(ismn, ean13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(ismn, ean13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(ismn, ean13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(ismn, ean13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(ismn, ean13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+---------------------------------------------------
+-- ISSN13:
+CREATE FUNCTION isnlt(issn13, issn13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(issn13, issn13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(issn13, issn13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(issn13, issn13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(issn13, issn13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(issn13, issn13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(issn13, issn)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(issn13, issn)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(issn13, issn)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(issn13, issn)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(issn13, issn)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(issn13, issn)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(issn13, ean13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(issn13, ean13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(issn13, ean13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(issn13, ean13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(issn13, ean13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(issn13, ean13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+---------------------------------------------------
+-- ISSN:
+CREATE FUNCTION isnlt(issn, issn)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(issn, issn)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(issn, issn)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(issn, issn)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(issn, issn)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(issn, issn)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(issn, issn13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(issn, issn13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(issn, issn13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(issn, issn13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(issn, issn13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(issn, issn13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(issn, ean13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(issn, ean13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(issn, ean13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(issn, ean13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(issn, ean13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(issn, ean13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+---------------------------------------------------
+-- UPC:
+CREATE FUNCTION isnlt(upc, upc)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(upc, upc)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(upc, upc)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(upc, upc)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(upc, upc)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(upc, upc)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION isnlt(upc, ean13)
+	RETURNS boolean
+	AS 'int8lt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnle(upc, ean13)
+	RETURNS boolean
+	AS 'int8le'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isneq(upc, ean13)
+	RETURNS boolean
+	AS 'int8eq'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnge(upc, ean13)
+	RETURNS boolean
+	AS 'int8ge'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isngt(upc, ean13)
+	RETURNS boolean
+	AS 'int8gt'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION isnne(upc, ean13)
+	RETURNS boolean
+	AS 'int8ne'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+--
+-- Now the operators:
+--
+
+--
+-- EAN13 operators:
+--
+---------------------------------------------------
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ean13,
+	RIGHTARG = ean13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ean13,
+	RIGHTARG = ean13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ean13,
+	RIGHTARG = ean13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ean13,
+	RIGHTARG = ean13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ean13,
+	RIGHTARG = ean13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ean13,
+	RIGHTARG = ean13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ean13,
+	RIGHTARG = isbn13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ean13,
+	RIGHTARG = isbn13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ean13,
+	RIGHTARG = isbn13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ean13,
+	RIGHTARG = isbn13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ean13,
+	RIGHTARG = isbn13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ean13,
+	RIGHTARG = isbn13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = isbn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = isbn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = isbn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = isbn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = isbn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = isbn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ean13,
+	RIGHTARG = ismn13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ean13,
+	RIGHTARG = ismn13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ean13,
+	RIGHTARG = ismn13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ean13,
+	RIGHTARG = ismn13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel);
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ean13,
+	RIGHTARG = ismn13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel);
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ean13,
+	RIGHTARG = ismn13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ismn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ismn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ismn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ismn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ismn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ismn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ean13,
+	RIGHTARG = issn13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ean13,
+	RIGHTARG = issn13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ean13,
+	RIGHTARG = issn13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ean13,
+	RIGHTARG = issn13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel);
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ean13,
+	RIGHTARG = issn13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel);
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ean13,
+	RIGHTARG = issn13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ean13,
+	RIGHTARG = isbn,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ean13,
+	RIGHTARG = isbn,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ean13,
+	RIGHTARG = isbn,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ean13,
+	RIGHTARG = isbn,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel);
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ean13,
+	RIGHTARG = isbn,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel);
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ean13,
+	RIGHTARG = isbn,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ean13,
+	RIGHTARG = ismn,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ean13,
+	RIGHTARG = ismn,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ean13,
+	RIGHTARG = ismn,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ean13,
+	RIGHTARG = ismn,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel);
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ean13,
+	RIGHTARG = ismn,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel);
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ean13,
+	RIGHTARG = ismn,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ean13,
+	RIGHTARG = issn,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ean13,
+	RIGHTARG = issn,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ean13,
+	RIGHTARG = issn,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ean13,
+	RIGHTARG = issn,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel);
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ean13,
+	RIGHTARG = issn,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel);
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ean13,
+	RIGHTARG = issn,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ean13,
+	RIGHTARG = upc,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ean13,
+	RIGHTARG = upc,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ean13,
+	RIGHTARG = upc,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ean13,
+	RIGHTARG = upc,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel);
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ean13,
+	RIGHTARG = upc,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel);
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ean13,
+	RIGHTARG = upc,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+--
+-- ISBN13 operators:
+--
+---------------------------------------------------
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = isbn13,
+	RIGHTARG = isbn13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = isbn13,
+	RIGHTARG = isbn13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = isbn13,
+	RIGHTARG = isbn13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = isbn13,
+	RIGHTARG = isbn13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = isbn13,
+	RIGHTARG = isbn13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = isbn13,
+	RIGHTARG = isbn13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = isbn13,
+	RIGHTARG = isbn,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = isbn13,
+	RIGHTARG = isbn,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = isbn13,
+	RIGHTARG = isbn,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = isbn13,
+	RIGHTARG = isbn,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = isbn13,
+	RIGHTARG = isbn,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = isbn13,
+	RIGHTARG = isbn,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+--
+-- ISBN operators:
+--
+---------------------------------------------------
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = isbn,
+	RIGHTARG = isbn,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = isbn,
+	RIGHTARG = isbn,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = isbn,
+	RIGHTARG = isbn,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = isbn,
+	RIGHTARG = isbn,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = isbn,
+	RIGHTARG = isbn,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = isbn,
+	RIGHTARG = isbn,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = isbn,
+	RIGHTARG = isbn13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = isbn,
+	RIGHTARG = isbn13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = isbn,
+	RIGHTARG = isbn13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = isbn,
+	RIGHTARG = isbn13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = isbn,
+	RIGHTARG = isbn13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = isbn,
+	RIGHTARG = isbn13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = isbn,
+	RIGHTARG = ean13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = isbn,
+	RIGHTARG = ean13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = isbn,
+	RIGHTARG = ean13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = isbn,
+	RIGHTARG = ean13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = isbn,
+	RIGHTARG = ean13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = isbn,
+	RIGHTARG = ean13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+--
+-- ISMN13 operators:
+--
+---------------------------------------------------
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ismn13,
+	RIGHTARG = ismn13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ismn13,
+	RIGHTARG = ismn13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ismn13,
+	RIGHTARG = ismn13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ismn13,
+	RIGHTARG = ismn13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ismn13,
+	RIGHTARG = ismn13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ismn13,
+	RIGHTARG = ismn13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ismn13,
+	RIGHTARG = ismn,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ismn13,
+	RIGHTARG = ismn,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ismn13,
+	RIGHTARG = ismn,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ismn13,
+	RIGHTARG = ismn,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ismn13,
+	RIGHTARG = ismn,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ismn13,
+	RIGHTARG = ismn,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+--
+-- ISMN operators:
+--
+---------------------------------------------------
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ismn,
+	RIGHTARG = ismn,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ismn,
+	RIGHTARG = ismn,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ismn,
+	RIGHTARG = ismn,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ismn,
+	RIGHTARG = ismn,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ismn,
+	RIGHTARG = ismn,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ismn,
+	RIGHTARG = ismn,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ismn,
+	RIGHTARG = ismn13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ismn,
+	RIGHTARG = ismn13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ismn,
+	RIGHTARG = ismn13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ismn,
+	RIGHTARG = ismn13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ismn,
+	RIGHTARG = ismn13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ismn,
+	RIGHTARG = ismn13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = ismn,
+	RIGHTARG = ean13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = ismn,
+	RIGHTARG = ean13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = ismn,
+	RIGHTARG = ean13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = ismn,
+	RIGHTARG = ean13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = ismn,
+	RIGHTARG = ean13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = ismn,
+	RIGHTARG = ean13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+--
+-- ISSN13 operators:
+--
+---------------------------------------------------
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = issn13,
+	RIGHTARG = issn13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = issn13,
+	RIGHTARG = issn13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = issn13,
+	RIGHTARG = issn13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = issn13,
+	RIGHTARG = issn13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = issn13,
+	RIGHTARG = issn13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = issn13,
+	RIGHTARG = issn13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = issn13,
+	RIGHTARG = issn,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = issn13,
+	RIGHTARG = issn,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = issn13,
+	RIGHTARG = issn,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = issn13,
+	RIGHTARG = issn,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = issn13,
+	RIGHTARG = issn,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = issn13,
+	RIGHTARG = issn,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = issn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = issn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = issn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = issn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = issn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = issn13,
+	RIGHTARG = ean13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+--
+-- ISSN operators:
+--
+---------------------------------------------------
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = issn,
+	RIGHTARG = issn,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = issn,
+	RIGHTARG = issn,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = issn,
+	RIGHTARG = issn,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = issn,
+	RIGHTARG = issn,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = issn,
+	RIGHTARG = issn,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = issn,
+	RIGHTARG = issn,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = issn,
+	RIGHTARG = issn13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = issn,
+	RIGHTARG = issn13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = issn,
+	RIGHTARG = issn13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = issn,
+	RIGHTARG = issn13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = issn,
+	RIGHTARG = issn13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = issn,
+	RIGHTARG = issn13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = issn,
+	RIGHTARG = ean13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = issn,
+	RIGHTARG = ean13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = issn,
+	RIGHTARG = ean13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = issn,
+	RIGHTARG = ean13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = issn,
+	RIGHTARG = ean13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = issn,
+	RIGHTARG = ean13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+--
+-- UPC operators:
+--
+---------------------------------------------------
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = upc,
+	RIGHTARG = upc,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = upc,
+	RIGHTARG = upc,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = upc,
+	RIGHTARG = upc,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = upc,
+	RIGHTARG = upc,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = upc,
+	RIGHTARG = upc,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = upc,
+	RIGHTARG = upc,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+CREATE OPERATOR < (
+	PROCEDURE = isnlt,
+	LEFTARG = upc,
+	RIGHTARG = ean13,
+	COMMUTATOR = >,
+	NEGATOR = >=,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR <= (
+	PROCEDURE = isnle,
+	LEFTARG = upc,
+	RIGHTARG = ean13,
+	COMMUTATOR = >=,
+	NEGATOR = >,
+	RESTRICT = scalarltsel,
+	JOIN = scalarltjoinsel);
+CREATE OPERATOR = (
+	PROCEDURE = isneq,
+	LEFTARG = upc,
+	RIGHTARG = ean13,
+	COMMUTATOR = =,
+	NEGATOR = <>,
+	RESTRICT = eqsel,
+	JOIN = eqjoinsel,
+	MERGES,
+	HASHES);
+CREATE OPERATOR >= (
+	PROCEDURE = isnge,
+	LEFTARG = upc,
+	RIGHTARG = ean13,
+	COMMUTATOR = <=,
+	NEGATOR = <,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR > (
+	PROCEDURE = isngt,
+	LEFTARG = upc,
+	RIGHTARG = ean13,
+	COMMUTATOR = <,
+	NEGATOR = <=,
+	RESTRICT = scalargtsel,
+	JOIN = scalargtjoinsel );
+CREATE OPERATOR <> (
+	PROCEDURE = isnne,
+	LEFTARG = upc,
+	RIGHTARG = ean13,
+	COMMUTATOR = <>,
+	NEGATOR = =,
+	RESTRICT = neqsel,
+	JOIN = neqjoinsel);
+
+--
+-- Operator families for the various operator classes:
+--
+---------------------------------------------------
+
+CREATE OPERATOR FAMILY isn_ops USING btree;
+CREATE OPERATOR FAMILY isn_ops USING hash;
+
+--
+-- Operator classes:
+--
+---------------------------------------------------
+-- EAN13:
+CREATE FUNCTION btean13cmp(ean13, ean13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS ean13_ops DEFAULT
+	FOR TYPE ean13 USING btree FAMILY isn_ops AS
+	OPERATOR 1  <,
+	OPERATOR 2  <=,
+	OPERATOR 3  =,
+	OPERATOR 4  >=,
+	OPERATOR 5  >,
+	FUNCTION 1  btean13cmp(ean13, ean13);
+
+CREATE FUNCTION hashean13(ean13)
+	RETURNS int4
+	AS 'hashint8'
+	LANGUAGE 'internal' IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS ean13_ops DEFAULT
+	FOR TYPE ean13 USING hash FAMILY isn_ops AS
+	OPERATOR 1  =,
+	FUNCTION 1  hashean13(ean13);
+
+-- EAN13 vs other types:
+CREATE FUNCTION btean13cmp(ean13, isbn13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION btean13cmp(ean13, ismn13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION btean13cmp(ean13, issn13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION btean13cmp(ean13, isbn)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION btean13cmp(ean13, ismn)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION btean13cmp(ean13, issn)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION btean13cmp(ean13, upc)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+ALTER OPERATOR FAMILY isn_ops USING btree ADD
+	OPERATOR 1  < (ean13, isbn13),
+	OPERATOR 1  < (ean13, ismn13),
+	OPERATOR 1  < (ean13, issn13),
+	OPERATOR 1  < (ean13, isbn),
+	OPERATOR 1  < (ean13, ismn),
+	OPERATOR 1  < (ean13, issn),
+	OPERATOR 1  < (ean13, upc),
+	OPERATOR 2  <= (ean13, isbn13),
+	OPERATOR 2  <= (ean13, ismn13),
+	OPERATOR 2  <= (ean13, issn13),
+	OPERATOR 2  <= (ean13, isbn),
+	OPERATOR 2  <= (ean13, ismn),
+	OPERATOR 2  <= (ean13, issn),
+	OPERATOR 2  <= (ean13, upc),
+	OPERATOR 3  = (ean13, isbn13),
+	OPERATOR 3  = (ean13, ismn13),
+	OPERATOR 3  = (ean13, issn13),
+	OPERATOR 3  = (ean13, isbn),
+	OPERATOR 3  = (ean13, ismn),
+	OPERATOR 3  = (ean13, issn),
+	OPERATOR 3  = (ean13, upc),
+	OPERATOR 4  >= (ean13, isbn13),
+	OPERATOR 4  >= (ean13, ismn13),
+	OPERATOR 4  >= (ean13, issn13),
+	OPERATOR 4  >= (ean13, isbn),
+	OPERATOR 4  >= (ean13, ismn),
+	OPERATOR 4  >= (ean13, issn),
+	OPERATOR 4  >= (ean13, upc),
+	OPERATOR 5  > (ean13, isbn13),
+	OPERATOR 5  > (ean13, ismn13),
+	OPERATOR 5  > (ean13, issn13),
+	OPERATOR 5  > (ean13, isbn),
+	OPERATOR 5  > (ean13, ismn),
+	OPERATOR 5  > (ean13, issn),
+	OPERATOR 5  > (ean13, upc),
+	FUNCTION 1  btean13cmp(ean13, isbn13),
+	FUNCTION 1  btean13cmp(ean13, ismn13),
+	FUNCTION 1  btean13cmp(ean13, issn13),
+	FUNCTION 1  btean13cmp(ean13, isbn),
+	FUNCTION 1  btean13cmp(ean13, ismn),
+	FUNCTION 1  btean13cmp(ean13, issn),
+	FUNCTION 1  btean13cmp(ean13, upc);
+
+ALTER OPERATOR FAMILY isn_ops USING hash ADD
+	OPERATOR 1  = (ean13, isbn13),
+	OPERATOR 1  = (ean13, ismn13),
+	OPERATOR 1  = (ean13, issn13),
+	OPERATOR 1  = (ean13, isbn),
+	OPERATOR 1  = (ean13, ismn),
+	OPERATOR 1  = (ean13, issn),
+	OPERATOR 1  = (ean13, upc);
+
+---------------------------------------------------
+-- ISBN13:
+CREATE FUNCTION btisbn13cmp(isbn13, isbn13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS isbn13_ops DEFAULT
+	FOR TYPE isbn13 USING btree FAMILY isn_ops AS
+	OPERATOR 1  <,
+	OPERATOR 2  <=,
+	OPERATOR 3  =,
+	OPERATOR 4  >=,
+	OPERATOR 5  >,
+	FUNCTION 1  btisbn13cmp(isbn13, isbn13);
+
+CREATE FUNCTION hashisbn13(isbn13)
+	RETURNS int4
+	AS 'hashint8'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS isbn13_ops DEFAULT
+	FOR TYPE isbn13 USING hash FAMILY isn_ops AS
+	OPERATOR 1  =,
+	FUNCTION 1  hashisbn13(isbn13);
+
+-- ISBN13 vs other types:
+CREATE FUNCTION btisbn13cmp(isbn13, ean13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION btisbn13cmp(isbn13, isbn)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+ALTER OPERATOR FAMILY isn_ops USING btree ADD
+	OPERATOR 1  < (isbn13, ean13),
+	OPERATOR 1  < (isbn13, isbn),
+	OPERATOR 2  <= (isbn13, ean13),
+	OPERATOR 2  <= (isbn13, isbn),
+	OPERATOR 3  = (isbn13, ean13),
+	OPERATOR 3  = (isbn13, isbn),
+	OPERATOR 4  >= (isbn13, ean13),
+	OPERATOR 4  >= (isbn13, isbn),
+	OPERATOR 5  > (isbn13, ean13),
+	OPERATOR 5  > (isbn13, isbn),
+	FUNCTION 1  btisbn13cmp(isbn13, ean13),
+	FUNCTION 1  btisbn13cmp(isbn13, isbn);
+
+ALTER OPERATOR FAMILY isn_ops USING hash ADD
+	OPERATOR 1  = (isbn13, ean13),
+	OPERATOR 1  = (isbn13, isbn);
+
+---------------------------------------------------
+-- ISBN:
+CREATE FUNCTION btisbncmp(isbn, isbn)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS isbn_ops DEFAULT
+	FOR TYPE isbn USING btree FAMILY isn_ops AS
+	OPERATOR 1  <,
+	OPERATOR 2  <=,
+	OPERATOR 3  =,
+	OPERATOR 4  >=,
+	OPERATOR 5  >,
+	FUNCTION 1  btisbncmp(isbn, isbn);
+
+CREATE FUNCTION hashisbn(isbn)
+	RETURNS int4
+	AS 'hashint8'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS isbn_ops DEFAULT
+	FOR TYPE isbn USING hash FAMILY isn_ops AS
+	OPERATOR 1  =,
+	FUNCTION 1  hashisbn(isbn);
+
+-- ISBN vs other types:
+CREATE FUNCTION btisbncmp(isbn, ean13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION btisbncmp(isbn, isbn13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+ALTER OPERATOR FAMILY isn_ops USING btree ADD
+	OPERATOR 1  < (isbn, ean13),
+	OPERATOR 1  < (isbn, isbn13),
+	OPERATOR 2  <= (isbn, ean13),
+	OPERATOR 2  <= (isbn, isbn13),
+	OPERATOR 3  = (isbn, ean13),
+	OPERATOR 3  = (isbn, isbn13),
+	OPERATOR 4  >= (isbn, ean13),
+	OPERATOR 4  >= (isbn, isbn13),
+	OPERATOR 5  > (isbn, ean13),
+	OPERATOR 5  > (isbn, isbn13),
+	FUNCTION 1  btisbncmp(isbn, ean13),
+	FUNCTION 1  btisbncmp(isbn, isbn13);
+
+ALTER OPERATOR FAMILY isn_ops USING hash ADD
+	OPERATOR 1  = (isbn, ean13),
+	OPERATOR 1  = (isbn, isbn13);
+
+---------------------------------------------------
+-- ISMN13:
+CREATE FUNCTION btismn13cmp(ismn13, ismn13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS ismn13_ops DEFAULT
+	FOR TYPE ismn13 USING btree FAMILY isn_ops AS
+	OPERATOR 1  <,
+	OPERATOR 2  <=,
+	OPERATOR 3  =,
+	OPERATOR 4  >=,
+	OPERATOR 5  >,
+	FUNCTION 1  btismn13cmp(ismn13, ismn13);
+
+CREATE FUNCTION hashismn13(ismn13)
+	RETURNS int4
+	AS 'hashint8'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS ismn13_ops DEFAULT
+	FOR TYPE ismn13 USING hash FAMILY isn_ops AS
+	OPERATOR 1  =,
+	FUNCTION 1  hashismn13(ismn13);
+
+-- ISMN13 vs other types:
+CREATE FUNCTION btismn13cmp(ismn13, ean13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION btismn13cmp(ismn13, ismn)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+ALTER OPERATOR FAMILY isn_ops USING btree ADD
+	OPERATOR 1  < (ismn13, ean13),
+	OPERATOR 1  < (ismn13, ismn),
+	OPERATOR 2  <= (ismn13, ean13),
+	OPERATOR 2  <= (ismn13, ismn),
+	OPERATOR 3  = (ismn13, ean13),
+	OPERATOR 3  = (ismn13, ismn),
+	OPERATOR 4  >= (ismn13, ean13),
+	OPERATOR 4  >= (ismn13, ismn),
+	OPERATOR 5  > (ismn13, ean13),
+	OPERATOR 5  > (ismn13, ismn),
+	FUNCTION 1  btismn13cmp(ismn13, ean13),
+	FUNCTION 1  btismn13cmp(ismn13, ismn);
+
+ALTER OPERATOR FAMILY isn_ops USING hash ADD
+	OPERATOR 1  = (ismn13, ean13),
+	OPERATOR 1  = (ismn13, ismn);
+
+---------------------------------------------------
+-- ISMN:
+CREATE FUNCTION btismncmp(ismn, ismn)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS ismn_ops DEFAULT
+	FOR TYPE ismn USING btree FAMILY isn_ops AS
+	OPERATOR 1  <,
+	OPERATOR 2  <=,
+	OPERATOR 3  =,
+	OPERATOR 4  >=,
+	OPERATOR 5  >,
+	FUNCTION 1  btismncmp(ismn, ismn);
+
+CREATE FUNCTION hashismn(ismn)
+	RETURNS int4
+	AS 'hashint8'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS ismn_ops DEFAULT
+	FOR TYPE ismn USING hash FAMILY isn_ops AS
+	OPERATOR 1  =,
+	FUNCTION 1  hashismn(ismn);
+
+-- ISMN vs other types:
+CREATE FUNCTION btismncmp(ismn, ean13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION btismncmp(ismn, ismn13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+ALTER OPERATOR FAMILY isn_ops USING btree ADD
+	OPERATOR 1  < (ismn, ean13),
+	OPERATOR 1  < (ismn, ismn13),
+	OPERATOR 2  <= (ismn, ean13),
+	OPERATOR 2  <= (ismn, ismn13),
+	OPERATOR 3  = (ismn, ean13),
+	OPERATOR 3  = (ismn, ismn13),
+	OPERATOR 4  >= (ismn, ean13),
+	OPERATOR 4  >= (ismn, ismn13),
+	OPERATOR 5  > (ismn, ean13),
+	OPERATOR 5  > (ismn, ismn13),
+	FUNCTION 1  btismncmp(ismn, ean13),
+	FUNCTION 1  btismncmp(ismn, ismn13);
+
+ALTER OPERATOR FAMILY isn_ops USING hash ADD
+	OPERATOR 1  = (ismn, ean13),
+	OPERATOR 1  = (ismn, ismn13);
+
+---------------------------------------------------
+-- ISSN13:
+CREATE FUNCTION btissn13cmp(issn13, issn13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS issn13_ops DEFAULT
+	FOR TYPE issn13 USING btree FAMILY isn_ops AS
+	OPERATOR 1  <,
+	OPERATOR 2  <=,
+	OPERATOR 3  =,
+	OPERATOR 4  >=,
+	OPERATOR 5  >,
+	FUNCTION 1  btissn13cmp(issn13, issn13);
+
+CREATE FUNCTION hashissn13(issn13)
+	RETURNS int4
+	AS 'hashint8'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS issn13_ops DEFAULT
+	FOR TYPE issn13 USING hash FAMILY isn_ops AS
+	OPERATOR 1  =,
+	FUNCTION 1  hashissn13(issn13);
+
+-- ISSN13 vs other types:
+CREATE FUNCTION btissn13cmp(issn13, ean13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION btissn13cmp(issn13, issn)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+ALTER OPERATOR FAMILY isn_ops USING btree ADD
+	OPERATOR 1  < (issn13, ean13),
+	OPERATOR 1  < (issn13, issn),
+	OPERATOR 2  <= (issn13, ean13),
+	OPERATOR 2  <= (issn13, issn),
+	OPERATOR 3  = (issn13, ean13),
+	OPERATOR 3  = (issn13, issn),
+	OPERATOR 4  >= (issn13, ean13),
+	OPERATOR 4  >= (issn13, issn),
+	OPERATOR 5  > (issn13, ean13),
+	OPERATOR 5  > (issn13, issn),
+	FUNCTION 1  btissn13cmp(issn13, ean13),
+	FUNCTION 1  btissn13cmp(issn13, issn);
+
+ALTER OPERATOR FAMILY isn_ops USING hash ADD
+	OPERATOR 1  = (issn13, ean13),
+	OPERATOR 1  = (issn13, issn);
+
+---------------------------------------------------
+-- ISSN:
+CREATE FUNCTION btissncmp(issn, issn)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS issn_ops DEFAULT
+	FOR TYPE issn USING btree FAMILY isn_ops AS
+	OPERATOR 1  <,
+	OPERATOR 2  <=,
+	OPERATOR 3  =,
+	OPERATOR 4  >=,
+	OPERATOR 5  >,
+	FUNCTION 1  btissncmp(issn, issn);
+
+CREATE FUNCTION hashissn(issn)
+	RETURNS int4
+	AS 'hashint8'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS issn_ops DEFAULT
+	FOR TYPE issn USING hash FAMILY isn_ops AS
+	OPERATOR 1  =,
+	FUNCTION 1  hashissn(issn);
+
+-- ISSN vs other types:
+CREATE FUNCTION btissncmp(issn, ean13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION btissncmp(issn, issn13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+ALTER OPERATOR FAMILY isn_ops USING btree ADD
+	OPERATOR 1  < (issn, ean13),
+	OPERATOR 1  < (issn, issn13),
+	OPERATOR 2  <= (issn, ean13),
+	OPERATOR 2  <= (issn, issn13),
+	OPERATOR 3  = (issn, ean13),
+	OPERATOR 3  = (issn, issn13),
+	OPERATOR 4  >= (issn, ean13),
+	OPERATOR 4  >= (issn, issn13),
+	OPERATOR 5  > (issn, ean13),
+	OPERATOR 5  > (issn, issn13),
+	FUNCTION 1  btissncmp(issn, ean13),
+	FUNCTION 1  btissncmp(issn, issn13);
+
+ALTER OPERATOR FAMILY isn_ops USING hash ADD
+	OPERATOR 1  = (issn, ean13),
+	OPERATOR 1  = (issn, issn13);
+
+---------------------------------------------------
+-- UPC:
+CREATE FUNCTION btupccmp(upc, upc)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS upc_ops DEFAULT
+	FOR TYPE upc USING btree FAMILY isn_ops AS
+	OPERATOR 1  <,
+	OPERATOR 2  <=,
+	OPERATOR 3  =,
+	OPERATOR 4  >=,
+	OPERATOR 5  >,
+	FUNCTION 1  btupccmp(upc, upc);
+
+CREATE FUNCTION hashupc(upc)
+	RETURNS int4
+	AS 'hashint8'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE OPERATOR CLASS upc_ops DEFAULT
+	FOR TYPE upc USING hash FAMILY isn_ops AS
+	OPERATOR 1  =,
+	FUNCTION 1  hashupc(upc);
+
+-- UPC vs other types:
+CREATE FUNCTION btupccmp(upc, ean13)
+	RETURNS int4
+	AS 'btint8cmp'
+	LANGUAGE 'internal'
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+ALTER OPERATOR FAMILY isn_ops USING btree ADD
+	OPERATOR 1  < (upc, ean13),
+	OPERATOR 2  <= (upc, ean13),
+	OPERATOR 3  = (upc, ean13),
+	OPERATOR 4  >= (upc, ean13),
+	OPERATOR 5  > (upc, ean13),
+	FUNCTION 1  btupccmp(upc, ean13);
+
+ALTER OPERATOR FAMILY isn_ops USING hash ADD
+	OPERATOR 1  = (upc, ean13);
+
+--
+-- Type casts:
+--
+---------------------------------------------------
+CREATE FUNCTION isbn13(ean13)
+RETURNS isbn13
+AS 'MODULE_PATHNAME', 'isbn_cast_from_ean13'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+CREATE FUNCTION ismn13(ean13)
+RETURNS ismn13
+AS 'MODULE_PATHNAME', 'ismn_cast_from_ean13'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+CREATE FUNCTION issn13(ean13)
+RETURNS issn13
+AS 'MODULE_PATHNAME', 'issn_cast_from_ean13'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+CREATE FUNCTION isbn(ean13)
+RETURNS isbn
+AS 'MODULE_PATHNAME', 'isbn_cast_from_ean13'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+CREATE FUNCTION ismn(ean13)
+RETURNS ismn
+AS 'MODULE_PATHNAME', 'ismn_cast_from_ean13'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+CREATE FUNCTION issn(ean13)
+RETURNS issn
+AS 'MODULE_PATHNAME', 'issn_cast_from_ean13'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+CREATE FUNCTION upc(ean13)
+RETURNS upc
+AS 'MODULE_PATHNAME', 'upc_cast_from_ean13'
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+
+CREATE CAST (ean13 AS isbn13) WITH FUNCTION isbn13(ean13);
+CREATE CAST (ean13 AS isbn) WITH FUNCTION isbn(ean13);
+CREATE CAST (ean13 AS ismn13) WITH FUNCTION ismn13(ean13);
+CREATE CAST (ean13 AS ismn) WITH FUNCTION ismn(ean13);
+CREATE CAST (ean13 AS issn13) WITH FUNCTION issn13(ean13);
+CREATE CAST (ean13 AS issn) WITH FUNCTION issn(ean13);
+CREATE CAST (ean13 AS upc) WITH FUNCTION upc(ean13);
+
+CREATE CAST (isbn13 AS ean13) WITHOUT FUNCTION AS ASSIGNMENT;
+CREATE CAST (isbn AS ean13) WITHOUT FUNCTION AS ASSIGNMENT;
+CREATE CAST (ismn13 AS ean13) WITHOUT FUNCTION AS ASSIGNMENT;
+CREATE CAST (ismn AS ean13) WITHOUT FUNCTION AS ASSIGNMENT;
+CREATE CAST (issn13 AS ean13) WITHOUT FUNCTION AS ASSIGNMENT;
+CREATE CAST (issn AS ean13) WITHOUT FUNCTION AS ASSIGNMENT;
+CREATE CAST (upc AS ean13) WITHOUT FUNCTION AS ASSIGNMENT;
+
+CREATE CAST (isbn AS isbn13) WITHOUT FUNCTION AS ASSIGNMENT;
+CREATE CAST (isbn13 AS isbn) WITHOUT FUNCTION AS ASSIGNMENT;
+CREATE CAST (ismn AS ismn13) WITHOUT FUNCTION AS ASSIGNMENT;
+CREATE CAST (ismn13 AS ismn) WITHOUT FUNCTION AS ASSIGNMENT;
+CREATE CAST (issn AS issn13) WITHOUT FUNCTION AS ASSIGNMENT;
+CREATE CAST (issn13 AS issn) WITHOUT FUNCTION AS ASSIGNMENT;
+
+--
+-- Validation stuff for lose types:
+--
+CREATE FUNCTION make_valid(ean13)
+	RETURNS ean13
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION make_valid(isbn13)
+	RETURNS isbn13
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION make_valid(ismn13)
+	RETURNS ismn13
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION make_valid(issn13)
+	RETURNS issn13
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION make_valid(isbn)
+	RETURNS isbn
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION make_valid(ismn)
+	RETURNS ismn
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION make_valid(issn)
+	RETURNS issn
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION make_valid(upc)
+	RETURNS upc
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+CREATE FUNCTION is_valid(ean13)
+	RETURNS boolean
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION is_valid(isbn13)
+	RETURNS boolean
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION is_valid(ismn13)
+	RETURNS boolean
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION is_valid(issn13)
+	RETURNS boolean
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION is_valid(isbn)
+	RETURNS boolean
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION is_valid(ismn)
+	RETURNS boolean
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION is_valid(issn)
+	RETURNS boolean
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+CREATE FUNCTION is_valid(upc)
+	RETURNS boolean
+	AS 'MODULE_PATHNAME'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL SAFE;
+
+--
+-- isn_weak(boolean) - Sets the weak input mode.
+-- This function is intended for testing use only!
+--
+CREATE FUNCTION isn_weak(boolean)
+	RETURNS boolean
+	AS 'MODULE_PATHNAME', 'accept_weak_input'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL RESTRICTED;
+
+--
+-- isn_weak() - Gets the weak input mode status
+--
+CREATE FUNCTION isn_weak()
+	RETURNS boolean
+	AS 'MODULE_PATHNAME', 'weak_input_status'
+	LANGUAGE C
+	IMMUTABLE STRICT
+	PARALLEL RESTRICTED;
diff --git a/contrib/isn/isn.c b/contrib/isn/isn.c
new file mode 100644
index 0000000..cf36bb6
--- /dev/null
+++ b/contrib/isn/isn.c
@@ -0,0 +1,1139 @@
+/*-------------------------------------------------------------------------
+ *
+ * isn.c
+ *	  PostgreSQL type definitions for ISNs (ISBN, ISMN, ISSN, EAN13, UPC)
+ *
+ * Author:	German Mendez Bravo (Kronuz)
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  contrib/isn/isn.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "EAN13.h"
+#include "ISBN.h"
+#include "ISMN.h"
+#include "ISSN.h"
+#include "UPC.h"
+#include "fmgr.h"
+#include "isn.h"
+#include "utils/builtins.h"
+
+PG_MODULE_MAGIC;
+
+#ifdef USE_ASSERT_CHECKING
+#define ISN_DEBUG 1
+#else
+#define ISN_DEBUG 0
+#endif
+
+#define MAXEAN13LEN 18
+
+enum isn_type
+{
+	INVALID, ANY, EAN13, ISBN, ISMN, ISSN, UPC
+};
+
+static const char *const isn_names[] = {"EAN13/UPC/ISxN", "EAN13/UPC/ISxN", "EAN13", "ISBN", "ISMN", "ISSN", "UPC"};
+
+static bool g_weak = false;
+
+
+/***********************************************************************
+ **
+ **		Routines for EAN13/UPC/ISxNs.
+ **
+ ** Note:
+ **  In this code, a normalized string is one that is known to be a valid
+ **  ISxN number containing only digits and hyphens and with enough space
+ **  to hold the full 13 digits plus the maximum of four hyphens.
+ ***********************************************************************/
+
+/*----------------------------------------------------------
+ * Debugging routines.
+ *---------------------------------------------------------*/
+
+/*
+ * Check if the table and its index is correct (just for debugging)
+ */
+pg_attribute_unused()
+static bool
+check_table(const char *(*TABLE)[2], const unsigned TABLE_index[10][2])
+{
+	const char *aux1,
+			   *aux2;
+	int			a,
+				b,
+				x = 0,
+				y = -1,
+				i = 0,
+				j,
+				init = 0;
+
+	if (TABLE == NULL || TABLE_index == NULL)
+		return true;
+
+	while (TABLE[i][0] && TABLE[i][1])
+	{
+		aux1 = TABLE[i][0];
+		aux2 = TABLE[i][1];
+
+		/* must always start with a digit: */
+		if (!isdigit((unsigned char) *aux1) || !isdigit((unsigned char) *aux2))
+			goto invalidtable;
+		a = *aux1 - '0';
+		b = *aux2 - '0';
+
+		/* must always have the same format and length: */
+		while (*aux1 && *aux2)
+		{
+			if (!(isdigit((unsigned char) *aux1) &&
+				  isdigit((unsigned char) *aux2)) &&
+				(*aux1 != *aux2 || *aux1 != '-'))
+				goto invalidtable;
+			aux1++;
+			aux2++;
+		}
+		if (*aux1 != *aux2)
+			goto invalidtable;
+
+		/* found a new range */
+		if (a > y)
+		{
+			/* check current range in the index: */
+			for (j = x; j <= y; j++)
+			{
+				if (TABLE_index[j][0] != init)
+					goto invalidindex;
+				if (TABLE_index[j][1] != i - init)
+					goto invalidindex;
+			}
+			init = i;
+			x = a;
+		}
+
+		/* Always get the new limit */
+		y = b;
+		if (y < x)
+			goto invalidtable;
+		i++;
+	}
+
+	return true;
+
+invalidtable:
+	elog(DEBUG1, "invalid table near {\"%s\", \"%s\"} (pos: %d)",
+		 TABLE[i][0], TABLE[i][1], i);
+	return false;
+
+invalidindex:
+	elog(DEBUG1, "index %d is invalid", j);
+	return false;
+}
+
+/*----------------------------------------------------------
+ * Formatting and conversion routines.
+ *---------------------------------------------------------*/
+
+static unsigned
+dehyphenate(char *bufO, char *bufI)
+{
+	unsigned	ret = 0;
+
+	while (*bufI)
+	{
+		if (isdigit((unsigned char) *bufI))
+		{
+			*bufO++ = *bufI;
+			ret++;
+		}
+		bufI++;
+	}
+	*bufO = '\0';
+	return ret;
+}
+
+/*
+ * hyphenate --- Try to hyphenate, in-place, the string starting at bufI
+ *				  into bufO using the given hyphenation range TABLE.
+ *				  Assumes the input string to be used is of only digits.
+ *
+ * Returns the number of characters actually hyphenated.
+ */
+static unsigned
+hyphenate(char *bufO, char *bufI, const char *(*TABLE)[2], const unsigned TABLE_index[10][2])
+{
+	unsigned	ret = 0;
+	const char *ean_aux1,
+			   *ean_aux2,
+			   *ean_p;
+	char	   *firstdig,
+			   *aux1,
+			   *aux2;
+	unsigned	search,
+				upper,
+				lower,
+				step;
+	bool		ean_in1,
+				ean_in2;
+
+	/* just compress the string if no further hyphenation is required */
+	if (TABLE == NULL || TABLE_index == NULL)
+	{
+		while (*bufI)
+		{
+			*bufO++ = *bufI++;
+			ret++;
+		}
+		*bufO = '\0';
+		return (ret + 1);
+	}
+
+	/* add remaining hyphenations */
+
+	search = *bufI - '0';
+	upper = lower = TABLE_index[search][0];
+	upper += TABLE_index[search][1];
+	lower--;
+
+	step = (upper - lower) / 2;
+	if (step == 0)
+		return 0;
+	search = lower + step;
+
+	firstdig = bufI;
+	ean_in1 = ean_in2 = false;
+	ean_aux1 = TABLE[search][0];
+	ean_aux2 = TABLE[search][1];
+	do
+	{
+		if ((ean_in1 || *firstdig >= *ean_aux1) && (ean_in2 || *firstdig <= *ean_aux2))
+		{
+			if (*firstdig > *ean_aux1)
+				ean_in1 = true;
+			if (*firstdig < *ean_aux2)
+				ean_in2 = true;
+			if (ean_in1 && ean_in2)
+				break;
+
+			firstdig++, ean_aux1++, ean_aux2++;
+			if (!(*ean_aux1 && *ean_aux2 && *firstdig))
+				break;
+			if (!isdigit((unsigned char) *ean_aux1))
+				ean_aux1++, ean_aux2++;
+		}
+		else
+		{
+			/*
+			 * check in what direction we should go and move the pointer
+			 * accordingly
+			 */
+			if (*firstdig < *ean_aux1 && !ean_in1)
+				upper = search;
+			else
+				lower = search;
+
+			step = (upper - lower) / 2;
+			search = lower + step;
+
+			/* Initialize stuff again: */
+			firstdig = bufI;
+			ean_in1 = ean_in2 = false;
+			ean_aux1 = TABLE[search][0];
+			ean_aux2 = TABLE[search][1];
+		}
+	} while (step);
+
+	if (step)
+	{
+		aux1 = bufO;
+		aux2 = bufI;
+		ean_p = TABLE[search][0];
+		while (*ean_p && *aux2)
+		{
+			if (*ean_p++ != '-')
+				*aux1++ = *aux2++;
+			else
+				*aux1++ = '-';
+			ret++;
+		}
+		*aux1++ = '-';
+		*aux1 = *aux2;			/* add a lookahead char */
+		return (ret + 1);
+	}
+	return ret;
+}
+
+/*
+ * weight_checkdig -- Receives a buffer with a normalized ISxN string number,
+ *					   and the length to weight.
+ *
+ * Returns the weight of the number (the check digit value, 0-10)
+ */
+static unsigned
+weight_checkdig(char *isn, unsigned size)
+{
+	unsigned	weight = 0;
+
+	while (*isn && size > 1)
+	{
+		if (isdigit((unsigned char) *isn))
+		{
+			weight += size-- * (*isn - '0');
+		}
+		isn++;
+	}
+	weight = weight % 11;
+	if (weight != 0)
+		weight = 11 - weight;
+	return weight;
+}
+
+
+/*
+ * checkdig --- Receives a buffer with a normalized ISxN string number,
+ *				 and the length to check.
+ *
+ * Returns the check digit value (0-9)
+ */
+static unsigned
+checkdig(char *num, unsigned size)
+{
+	unsigned	check = 0,
+				check3 = 0;
+	unsigned	pos = 0;
+
+	if (*num == 'M')
+	{							/* ISMN start with 'M' */
+		check3 = 3;
+		pos = 1;
+	}
+	while (*num && size > 1)
+	{
+		if (isdigit((unsigned char) *num))
+		{
+			if (pos++ % 2)
+				check3 += *num - '0';
+			else
+				check += *num - '0';
+			size--;
+		}
+		num++;
+	}
+	check = (check + 3 * check3) % 10;
+	if (check != 0)
+		check = 10 - check;
+	return check;
+}
+
+/*
+ * ean2isn --- Try to convert an ean13 number to a UPC/ISxN number.
+ *			   This doesn't verify for a valid check digit.
+ *
+ * If errorOK is false, ereport a useful error message if the ean13 is bad.
+ * If errorOK is true, just return "false" for bad input.
+ */
+static bool
+ean2isn(ean13 ean, bool errorOK, ean13 *result, enum isn_type accept)
+{
+	enum isn_type type = INVALID;
+
+	char		buf[MAXEAN13LEN + 1];
+	char	   *aux;
+	unsigned	digval;
+	unsigned	search;
+	ean13		ret = ean;
+
+	ean >>= 1;
+	/* verify it's in the EAN13 range */
+	if (ean > UINT64CONST(9999999999999))
+		goto eantoobig;
+
+	/* convert the number */
+	search = 0;
+	aux = buf + 13;
+	*aux = '\0';				/* terminate string; aux points to last digit */
+	do
+	{
+		digval = (unsigned) (ean % 10); /* get the decimal value */
+		ean /= 10;				/* get next digit */
+		*--aux = (char) (digval + '0'); /* convert to ascii and store */
+	} while (ean && search++ < 12);
+	while (search++ < 12)
+		*--aux = '0';			/* fill the remaining EAN13 with '0' */
+
+	/* find out the data type: */
+	if (strncmp("978", buf, 3) == 0)
+	{							/* ISBN */
+		type = ISBN;
+	}
+	else if (strncmp("977", buf, 3) == 0)
+	{							/* ISSN */
+		type = ISSN;
+	}
+	else if (strncmp("9790", buf, 4) == 0)
+	{							/* ISMN */
+		type = ISMN;
+	}
+	else if (strncmp("979", buf, 3) == 0)
+	{							/* ISBN-13 */
+		type = ISBN;
+	}
+	else if (*buf == '0')
+	{							/* UPC */
+		type = UPC;
+	}
+	else
+	{
+		type = EAN13;
+	}
+	if (accept != ANY && accept != EAN13 && accept != type)
+		goto eanwrongtype;
+
+	*result = ret;
+	return true;
+
+eanwrongtype:
+	if (!errorOK)
+	{
+		if (type != EAN13)
+		{
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+					 errmsg("cannot cast EAN13(%s) to %s for number: \"%s\"",
+							isn_names[type], isn_names[accept], buf)));
+		}
+		else
+		{
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+					 errmsg("cannot cast %s to %s for number: \"%s\"",
+							isn_names[type], isn_names[accept], buf)));
+		}
+	}
+	return false;
+
+eantoobig:
+	if (!errorOK)
+	{
+		char		eanbuf[64];
+
+		/*
+		 * Format the number separately to keep the machine-dependent format
+		 * code out of the translatable message text
+		 */
+		snprintf(eanbuf, sizeof(eanbuf), EAN13_FORMAT, ean);
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("value \"%s\" is out of range for %s type",
+						eanbuf, isn_names[type])));
+	}
+	return false;
+}
+
+/*
+ * ean2UPC/ISxN --- Convert in-place a normalized EAN13 string to the corresponding
+ *					UPC/ISxN string number. Assumes the input string is normalized.
+ */
+static inline void
+ean2ISBN(char *isn)
+{
+	char	   *aux;
+	unsigned	check;
+
+	/*
+	 * The number should come in this format: 978-0-000-00000-0 or may be an
+	 * ISBN-13 number, 979-..., which does not have a short representation. Do
+	 * the short output version if possible.
+	 */
+	if (strncmp("978-", isn, 4) == 0)
+	{
+		/* Strip the first part and calculate the new check digit */
+		hyphenate(isn, isn + 4, NULL, NULL);
+		check = weight_checkdig(isn, 10);
+		aux = strchr(isn, '\0');
+		while (!isdigit((unsigned char) *--aux));
+		if (check == 10)
+			*aux = 'X';
+		else
+			*aux = check + '0';
+	}
+}
+
+static inline void
+ean2ISMN(char *isn)
+{
+	/* the number should come in this format: 979-0-000-00000-0 */
+	/* Just strip the first part and change the first digit ('0') to 'M' */
+	hyphenate(isn, isn + 4, NULL, NULL);
+	isn[0] = 'M';
+}
+
+static inline void
+ean2ISSN(char *isn)
+{
+	unsigned	check;
+
+	/* the number should come in this format: 977-0000-000-00-0 */
+	/* Strip the first part, crop, and calculate the new check digit */
+	hyphenate(isn, isn + 4, NULL, NULL);
+	check = weight_checkdig(isn, 8);
+	if (check == 10)
+		isn[8] = 'X';
+	else
+		isn[8] = check + '0';
+	isn[9] = '\0';
+}
+
+static inline void
+ean2UPC(char *isn)
+{
+	/* the number should come in this format: 000-000000000-0 */
+	/* Strip the first part, crop, and dehyphenate */
+	dehyphenate(isn, isn + 1);
+	isn[12] = '\0';
+}
+
+/*
+ * ean2* --- Converts a string of digits into an ean13 number.
+ *			  Assumes the input string is a string with only digits
+ *			  on it, and that it's within the range of ean13.
+ *
+ * Returns the ean13 value of the string.
+ */
+static ean13
+str2ean(const char *num)
+{
+	ean13		ean = 0;		/* current ean */
+
+	while (*num)
+	{
+		if (isdigit((unsigned char) *num))
+			ean = 10 * ean + (*num - '0');
+		num++;
+	}
+	return (ean << 1);			/* also give room to a flag */
+}
+
+/*
+ * ean2string --- Try to convert an ean13 number to a hyphenated string.
+ *				  Assumes there's enough space in result to hold
+ *				  the string (maximum MAXEAN13LEN+1 bytes)
+ *				  This doesn't verify for a valid check digit.
+ *
+ * If shortType is true, the returned string is in the old ISxN short format.
+ * If errorOK is false, ereport a useful error message if the string is bad.
+ * If errorOK is true, just return "false" for bad input.
+ */
+static bool
+ean2string(ean13 ean, bool errorOK, char *result, bool shortType)
+{
+	const char *(*TABLE)[2];
+	const unsigned (*TABLE_index)[2];
+	enum isn_type type = INVALID;
+
+	char	   *aux;
+	unsigned	digval;
+	unsigned	search;
+	char		valid = '\0';	/* was the number initially written with a
+								 * valid check digit? */
+
+	TABLE_index = ISBN_index;
+
+	if ((ean & 1) != 0)
+		valid = '!';
+	ean >>= 1;
+	/* verify it's in the EAN13 range */
+	if (ean > UINT64CONST(9999999999999))
+		goto eantoobig;
+
+	/* convert the number */
+	search = 0;
+	aux = result + MAXEAN13LEN;
+	*aux = '\0';				/* terminate string; aux points to last digit */
+	*--aux = valid;				/* append '!' for numbers with invalid but
+								 * corrected check digit */
+	do
+	{
+		digval = (unsigned) (ean % 10); /* get the decimal value */
+		ean /= 10;				/* get next digit */
+		*--aux = (char) (digval + '0'); /* convert to ascii and store */
+		if (search == 0)
+			*--aux = '-';		/* the check digit is always there */
+	} while (ean && search++ < 13);
+	while (search++ < 13)
+		*--aux = '0';			/* fill the remaining EAN13 with '0' */
+
+	/* The string should be in this form: ???DDDDDDDDDDDD-D" */
+	search = hyphenate(result, result + 3, EAN13_range, EAN13_index);
+
+	/* verify it's a logically valid EAN13 */
+	if (search == 0)
+	{
+		search = hyphenate(result, result + 3, NULL, NULL);
+		goto okay;
+	}
+
+	/* find out what type of hyphenation is needed: */
+	if (strncmp("978-", result, search) == 0)
+	{							/* ISBN -13 978-range */
+		/* The string should be in this form: 978-??000000000-0" */
+		type = ISBN;
+		TABLE = ISBN_range;
+		TABLE_index = ISBN_index;
+	}
+	else if (strncmp("977-", result, search) == 0)
+	{							/* ISSN */
+		/* The string should be in this form: 977-??000000000-0" */
+		type = ISSN;
+		TABLE = ISSN_range;
+		TABLE_index = ISSN_index;
+	}
+	else if (strncmp("979-0", result, search + 1) == 0)
+	{							/* ISMN */
+		/* The string should be in this form: 979-0?000000000-0" */
+		type = ISMN;
+		TABLE = ISMN_range;
+		TABLE_index = ISMN_index;
+	}
+	else if (strncmp("979-", result, search) == 0)
+	{							/* ISBN-13 979-range */
+		/* The string should be in this form: 979-??000000000-0" */
+		type = ISBN;
+		TABLE = ISBN_range_new;
+		TABLE_index = ISBN_index_new;
+	}
+	else if (*result == '0')
+	{							/* UPC */
+		/* The string should be in this form: 000-00000000000-0" */
+		type = UPC;
+		TABLE = UPC_range;
+		TABLE_index = UPC_index;
+	}
+	else
+	{
+		type = EAN13;
+		TABLE = NULL;
+		TABLE_index = NULL;
+	}
+
+	/* verify it's a logically valid EAN13/UPC/ISxN */
+	digval = search;
+	search = hyphenate(result + digval, result + digval + 2, TABLE, TABLE_index);
+
+	/* verify it's a valid EAN13 */
+	if (search == 0)
+	{
+		search = hyphenate(result + digval, result + digval + 2, NULL, NULL);
+		goto okay;
+	}
+
+okay:
+	/* convert to the old short type: */
+	if (shortType)
+		switch (type)
+		{
+			case ISBN:
+				ean2ISBN(result);
+				break;
+			case ISMN:
+				ean2ISMN(result);
+				break;
+			case ISSN:
+				ean2ISSN(result);
+				break;
+			case UPC:
+				ean2UPC(result);
+				break;
+			default:
+				break;
+		}
+	return true;
+
+eantoobig:
+	if (!errorOK)
+	{
+		char		eanbuf[64];
+
+		/*
+		 * Format the number separately to keep the machine-dependent format
+		 * code out of the translatable message text
+		 */
+		snprintf(eanbuf, sizeof(eanbuf), EAN13_FORMAT, ean);
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("value \"%s\" is out of range for %s type",
+						eanbuf, isn_names[type])));
+	}
+	return false;
+}
+
+/*
+ * string2ean --- try to parse a string into an ean13.
+ *
+ * If errorOK is false, ereport a useful error message if the string is bad.
+ * If errorOK is true, just return "false" for bad input.
+ *
+ * if the input string ends with '!' it will always be treated as invalid
+ * (even if the check digit is valid)
+ */
+static bool
+string2ean(const char *str, bool errorOK, ean13 *result,
+		   enum isn_type accept)
+{
+	bool		digit,
+				last;
+	char		buf[17] = "                ";
+	char	   *aux1 = buf + 3; /* leave space for the first part, in case
+								 * it's needed */
+	const char *aux2 = str;
+	enum isn_type type = INVALID;
+	unsigned	check = 0,
+				rcheck = (unsigned) -1;
+	unsigned	length = 0;
+	bool		magic = false,
+				valid = true;
+
+	/* recognize and validate the number: */
+	while (*aux2 && length <= 13)
+	{
+		last = (*(aux2 + 1) == '!' || *(aux2 + 1) == '\0'); /* is the last character */
+		digit = (isdigit((unsigned char) *aux2) != 0);	/* is current character
+														 * a digit? */
+		if (*aux2 == '?' && last)	/* automagically calculate check digit if
+									 * it's '?' */
+			magic = digit = true;
+		if (length == 0 && (*aux2 == 'M' || *aux2 == 'm'))
+		{
+			/* only ISMN can be here */
+			if (type != INVALID)
+				goto eaninvalid;
+			type = ISMN;
+			*aux1++ = 'M';
+			length++;
+		}
+		else if (length == 7 && (digit || *aux2 == 'X' || *aux2 == 'x') && last)
+		{
+			/* only ISSN can be here */
+			if (type != INVALID)
+				goto eaninvalid;
+			type = ISSN;
+			*aux1++ = toupper((unsigned char) *aux2);
+			length++;
+		}
+		else if (length == 9 && (digit || *aux2 == 'X' || *aux2 == 'x') && last)
+		{
+			/* only ISBN and ISMN can be here */
+			if (type != INVALID && type != ISMN)
+				goto eaninvalid;
+			if (type == INVALID)
+				type = ISBN;	/* ISMN must start with 'M' */
+			*aux1++ = toupper((unsigned char) *aux2);
+			length++;
+		}
+		else if (length == 11 && digit && last)
+		{
+			/* only UPC can be here */
+			if (type != INVALID)
+				goto eaninvalid;
+			type = UPC;
+			*aux1++ = *aux2;
+			length++;
+		}
+		else if (*aux2 == '-' || *aux2 == ' ')
+		{
+			/* skip, we could validate but I think it's worthless */
+		}
+		else if (*aux2 == '!' && *(aux2 + 1) == '\0')
+		{
+			/* the invalid check digit suffix was found, set it */
+			if (!magic)
+				valid = false;
+			magic = true;
+		}
+		else if (!digit)
+		{
+			goto eaninvalid;
+		}
+		else
+		{
+			*aux1++ = *aux2;
+			if (++length > 13)
+				goto eantoobig;
+		}
+		aux2++;
+	}
+	*aux1 = '\0';				/* terminate the string */
+
+	/* find the current check digit value */
+	if (length == 13)
+	{
+		/* only EAN13 can be here */
+		if (type != INVALID)
+			goto eaninvalid;
+		type = EAN13;
+		check = buf[15] - '0';
+	}
+	else if (length == 12)
+	{
+		/* only UPC can be here */
+		if (type != UPC)
+			goto eaninvalid;
+		check = buf[14] - '0';
+	}
+	else if (length == 10)
+	{
+		if (type != ISBN && type != ISMN)
+			goto eaninvalid;
+		if (buf[12] == 'X')
+			check = 10;
+		else
+			check = buf[12] - '0';
+	}
+	else if (length == 8)
+	{
+		if (type != INVALID && type != ISSN)
+			goto eaninvalid;
+		type = ISSN;
+		if (buf[10] == 'X')
+			check = 10;
+		else
+			check = buf[10] - '0';
+	}
+	else
+		goto eaninvalid;
+
+	if (type == INVALID)
+		goto eaninvalid;
+
+	/* obtain the real check digit value, validate, and convert to ean13: */
+	if (accept == EAN13 && type != accept)
+		goto eanwrongtype;
+	if (accept != ANY && type != EAN13 && type != accept)
+		goto eanwrongtype;
+	switch (type)
+	{
+		case EAN13:
+			valid = (valid && ((rcheck = checkdig(buf + 3, 13)) == check || magic));
+			/* now get the subtype of EAN13: */
+			if (buf[3] == '0')
+				type = UPC;
+			else if (strncmp("977", buf + 3, 3) == 0)
+				type = ISSN;
+			else if (strncmp("978", buf + 3, 3) == 0)
+				type = ISBN;
+			else if (strncmp("9790", buf + 3, 4) == 0)
+				type = ISMN;
+			else if (strncmp("979", buf + 3, 3) == 0)
+				type = ISBN;
+			if (accept != EAN13 && accept != ANY && type != accept)
+				goto eanwrongtype;
+			break;
+		case ISMN:
+			memcpy(buf, "9790", 4); /* this isn't for sure yet, for now ISMN
+									 * it's only 9790 */
+			valid = (valid && ((rcheck = checkdig(buf, 13)) == check || magic));
+			break;
+		case ISBN:
+			memcpy(buf, "978", 3);
+			valid = (valid && ((rcheck = weight_checkdig(buf + 3, 10)) == check || magic));
+			break;
+		case ISSN:
+			memcpy(buf + 10, "00", 2);	/* append 00 as the normal issue
+										 * publication code */
+			memcpy(buf, "977", 3);
+			valid = (valid && ((rcheck = weight_checkdig(buf + 3, 8)) == check || magic));
+			break;
+		case UPC:
+			buf[2] = '0';
+			valid = (valid && ((rcheck = checkdig(buf + 2, 13)) == check || magic));
+		default:
+			break;
+	}
+
+	/* fix the check digit: */
+	for (aux1 = buf; *aux1 && *aux1 <= ' '; aux1++);
+	aux1[12] = checkdig(aux1, 13) + '0';
+	aux1[13] = '\0';
+
+	if (!valid && !magic)
+		goto eanbadcheck;
+
+	*result = str2ean(aux1);
+	*result |= valid ? 0 : 1;
+	return true;
+
+eanbadcheck:
+	if (g_weak)
+	{							/* weak input mode is activated: */
+		/* set the "invalid-check-digit-on-input" flag */
+		*result = str2ean(aux1);
+		*result |= 1;
+		return true;
+	}
+
+	if (!errorOK)
+	{
+		if (rcheck == (unsigned) -1)
+		{
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+					 errmsg("invalid %s number: \"%s\"",
+							isn_names[accept], str)));
+		}
+		else
+		{
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+					 errmsg("invalid check digit for %s number: \"%s\", should be %c",
+							isn_names[accept], str, (rcheck == 10) ? ('X') : (rcheck + '0'))));
+		}
+	}
+	return false;
+
+eaninvalid:
+	if (!errorOK)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+				 errmsg("invalid input syntax for %s number: \"%s\"",
+						isn_names[accept], str)));
+	return false;
+
+eanwrongtype:
+	if (!errorOK)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+				 errmsg("cannot cast %s to %s for number: \"%s\"",
+						isn_names[type], isn_names[accept], str)));
+	return false;
+
+eantoobig:
+	if (!errorOK)
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("value \"%s\" is out of range for %s type",
+						str, isn_names[accept])));
+	return false;
+}
+
+/*----------------------------------------------------------
+ * Exported routines.
+ *---------------------------------------------------------*/
+
+void		_PG_init(void);
+
+void
+_PG_init(void)
+{
+	if (ISN_DEBUG)
+	{
+		if (!check_table(EAN13_range, EAN13_index))
+			elog(ERROR, "EAN13 failed check");
+		if (!check_table(ISBN_range, ISBN_index))
+			elog(ERROR, "ISBN failed check");
+		if (!check_table(ISMN_range, ISMN_index))
+			elog(ERROR, "ISMN failed check");
+		if (!check_table(ISSN_range, ISSN_index))
+			elog(ERROR, "ISSN failed check");
+		if (!check_table(UPC_range, UPC_index))
+			elog(ERROR, "UPC failed check");
+	}
+}
+
+/* isn_out
+ */
+PG_FUNCTION_INFO_V1(isn_out);
+Datum
+isn_out(PG_FUNCTION_ARGS)
+{
+	ean13		val = PG_GETARG_EAN13(0);
+	char	   *result;
+	char		buf[MAXEAN13LEN + 1];
+
+	(void) ean2string(val, false, buf, true);
+
+	result = pstrdup(buf);
+	PG_RETURN_CSTRING(result);
+}
+
+/* ean13_out
+ */
+PG_FUNCTION_INFO_V1(ean13_out);
+Datum
+ean13_out(PG_FUNCTION_ARGS)
+{
+	ean13		val = PG_GETARG_EAN13(0);
+	char	   *result;
+	char		buf[MAXEAN13LEN + 1];
+
+	(void) ean2string(val, false, buf, false);
+
+	result = pstrdup(buf);
+	PG_RETURN_CSTRING(result);
+}
+
+/* ean13_in
+ */
+PG_FUNCTION_INFO_V1(ean13_in);
+Datum
+ean13_in(PG_FUNCTION_ARGS)
+{
+	const char *str = PG_GETARG_CSTRING(0);
+	ean13		result;
+
+	(void) string2ean(str, false, &result, EAN13);
+	PG_RETURN_EAN13(result);
+}
+
+/* isbn_in
+ */
+PG_FUNCTION_INFO_V1(isbn_in);
+Datum
+isbn_in(PG_FUNCTION_ARGS)
+{
+	const char *str = PG_GETARG_CSTRING(0);
+	ean13		result;
+
+	(void) string2ean(str, false, &result, ISBN);
+	PG_RETURN_EAN13(result);
+}
+
+/* ismn_in
+ */
+PG_FUNCTION_INFO_V1(ismn_in);
+Datum
+ismn_in(PG_FUNCTION_ARGS)
+{
+	const char *str = PG_GETARG_CSTRING(0);
+	ean13		result;
+
+	(void) string2ean(str, false, &result, ISMN);
+	PG_RETURN_EAN13(result);
+}
+
+/* issn_in
+ */
+PG_FUNCTION_INFO_V1(issn_in);
+Datum
+issn_in(PG_FUNCTION_ARGS)
+{
+	const char *str = PG_GETARG_CSTRING(0);
+	ean13		result;
+
+	(void) string2ean(str, false, &result, ISSN);
+	PG_RETURN_EAN13(result);
+}
+
+/* upc_in
+ */
+PG_FUNCTION_INFO_V1(upc_in);
+Datum
+upc_in(PG_FUNCTION_ARGS)
+{
+	const char *str = PG_GETARG_CSTRING(0);
+	ean13		result;
+
+	(void) string2ean(str, false, &result, UPC);
+	PG_RETURN_EAN13(result);
+}
+
+/* casting functions
+*/
+PG_FUNCTION_INFO_V1(isbn_cast_from_ean13);
+Datum
+isbn_cast_from_ean13(PG_FUNCTION_ARGS)
+{
+	ean13		val = PG_GETARG_EAN13(0);
+	ean13		result;
+
+	(void) ean2isn(val, false, &result, ISBN);
+
+	PG_RETURN_EAN13(result);
+}
+
+PG_FUNCTION_INFO_V1(ismn_cast_from_ean13);
+Datum
+ismn_cast_from_ean13(PG_FUNCTION_ARGS)
+{
+	ean13		val = PG_GETARG_EAN13(0);
+	ean13		result;
+
+	(void) ean2isn(val, false, &result, ISMN);
+
+	PG_RETURN_EAN13(result);
+}
+
+PG_FUNCTION_INFO_V1(issn_cast_from_ean13);
+Datum
+issn_cast_from_ean13(PG_FUNCTION_ARGS)
+{
+	ean13		val = PG_GETARG_EAN13(0);
+	ean13		result;
+
+	(void) ean2isn(val, false, &result, ISSN);
+
+	PG_RETURN_EAN13(result);
+}
+
+PG_FUNCTION_INFO_V1(upc_cast_from_ean13);
+Datum
+upc_cast_from_ean13(PG_FUNCTION_ARGS)
+{
+	ean13		val = PG_GETARG_EAN13(0);
+	ean13		result;
+
+	(void) ean2isn(val, false, &result, UPC);
+
+	PG_RETURN_EAN13(result);
+}
+
+
+/* is_valid - returns false if the "invalid-check-digit-on-input" is set
+ */
+PG_FUNCTION_INFO_V1(is_valid);
+Datum
+is_valid(PG_FUNCTION_ARGS)
+{
+	ean13		val = PG_GETARG_EAN13(0);
+
+	PG_RETURN_BOOL((val & 1) == 0);
+}
+
+/* make_valid - unsets the "invalid-check-digit-on-input" flag
+ */
+PG_FUNCTION_INFO_V1(make_valid);
+Datum
+make_valid(PG_FUNCTION_ARGS)
+{
+	ean13		val = PG_GETARG_EAN13(0);
+
+	val &= ~((ean13) 1);
+	PG_RETURN_EAN13(val);
+}
+
+/* this function temporarily sets weak input flag
+ * (to lose the strictness of check digit acceptance)
+ * It's a helper function, not intended to be used!!
+ */
+PG_FUNCTION_INFO_V1(accept_weak_input);
+Datum
+accept_weak_input(PG_FUNCTION_ARGS)
+{
+#ifdef ISN_WEAK_MODE
+	g_weak = PG_GETARG_BOOL(0);
+#else
+	/* function has no effect */
+#endif							/* ISN_WEAK_MODE */
+	PG_RETURN_BOOL(g_weak);
+}
+
+PG_FUNCTION_INFO_V1(weak_input_status);
+Datum
+weak_input_status(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(g_weak);
+}
diff --git a/contrib/isn/isn.control b/contrib/isn/isn.control
new file mode 100644
index 0000000..1cb5e2b
--- /dev/null
+++ b/contrib/isn/isn.control
@@ -0,0 +1,6 @@
+# isn extension
+comment = 'data types for international product numbering standards'
+default_version = '1.2'
+module_pathname = '$libdir/isn'
+relocatable = true
+trusted = true
diff --git a/contrib/isn/isn.h b/contrib/isn/isn.h
new file mode 100644
index 0000000..017f597
--- /dev/null
+++ b/contrib/isn/isn.h
@@ -0,0 +1,35 @@
+/*-------------------------------------------------------------------------
+ *
+ * isn.h
+ *	  PostgreSQL type definitions for ISNs (ISBN, ISMN, ISSN, EAN13, UPC)
+ *
+ * Author:	German Mendez Bravo (Kronuz)
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  contrib/isn/isn.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef ISN_H
+#define ISN_H
+
+#include "fmgr.h"
+
+#undef ISN_DEBUG
+#define ISN_WEAK_MODE
+
+/*
+ *	uint64 is the internal storage format for ISNs.
+ */
+typedef uint64 ean13;
+
+#define EAN13_FORMAT UINT64_FORMAT
+
+#define PG_GETARG_EAN13(n) PG_GETARG_INT64(n)
+#define PG_RETURN_EAN13(x) PG_RETURN_INT64(x)
+
+extern void initialize(void);
+
+#endif							/* ISN_H */
diff --git a/contrib/isn/sql/isn.sql b/contrib/isn/sql/isn.sql
new file mode 100644
index 0000000..71577d5
--- /dev/null
+++ b/contrib/isn/sql/isn.sql
@@ -0,0 +1,113 @@
+--
+-- Test ISN extension
+--
+
+CREATE EXTENSION isn;
+
+-- Check whether any of our opclasses fail amvalidate
+-- ... they will, because of missing cross-type operators
+SELECT amname, opcname
+FROM (SELECT amname, opcname, opc.oid
+      FROM pg_opclass opc LEFT JOIN pg_am am ON am.oid = opcmethod
+      WHERE opc.oid >= 16384
+      ORDER BY 1, 2 OFFSET 0) ss
+WHERE NOT amvalidate(oid);
+
+--
+-- test valid conversions
+--
+SELECT '9780123456786'::EAN13, -- old book
+       '9790123456785'::EAN13, -- music
+       '9791234567896'::EAN13, -- new book
+       '9771234567898'::EAN13, -- serial
+       '0123456789012'::EAN13, -- upc
+       '1234567890128'::EAN13;
+
+SELECT '9780123456786'::ISBN,
+       '123456789X'::ISBN,
+       '9780123456786'::ISBN13::ISBN,
+       '9780123456786'::EAN13::ISBN;
+
+SELECT -- new books, shown as ISBN13 even for ISBN...
+       '9791234567896'::ISBN,
+       '9791234567896'::ISBN13::ISBN,
+       '9791234567896'::EAN13::ISBN;
+
+SELECT '9780123456786'::ISBN13,
+       '123456789X'::ISBN13,
+       '9791234567896'::ISBN13,
+       '9791234567896'::EAN13::ISBN13;
+
+SELECT '9790123456785'::ISMN,
+       '9790123456785'::EAN13::ISMN,
+       'M123456785'::ISMN,
+       'M-1234-5678-5'::ISMN;
+
+SELECT '9790123456785'::ISMN13,
+       'M123456785'::ISMN13,
+       'M-1234-5678-5'::ISMN13;
+
+SELECT '9771234567003'::ISSN,
+       '12345679'::ISSN;
+
+SELECT '9771234567003'::ISSN13,
+       '12345679'::ISSN13,
+       '9771234567898'::ISSN13,
+       '9771234567898'::EAN13::ISSN13;
+
+SELECT '0123456789012'::UPC,
+       '0123456789012'::EAN13::UPC;
+
+--
+-- test invalid checksums
+--
+SELECT '1234567890'::ISBN;
+SELECT 'M123456780'::ISMN;
+SELECT '12345670'::ISSN;
+SELECT '9780123456780'::ISBN;
+SELECT '9791234567890'::ISBN13;
+SELECT '0123456789010'::UPC;
+SELECT '1234567890120'::EAN13;
+
+--
+-- test invalid conversions
+--
+SELECT '9790123456785'::ISBN; -- not a book
+SELECT '9771234567898'::ISBN; -- not a book
+SELECT '0123456789012'::ISBN; -- not a book
+
+SELECT '9790123456785'::ISBN13; -- not a book
+SELECT '9771234567898'::ISBN13; -- not a book
+SELECT '0123456789012'::ISBN13; -- not a book
+
+SELECT '9780123456786'::ISMN; -- not music
+SELECT '9771234567898'::ISMN; -- not music
+SELECT '9791234567896'::ISMN; -- not music
+SELECT '0123456789012'::ISMN; -- not music
+
+SELECT '9780123456786'::ISSN; -- not serial
+SELECT '9790123456785'::ISSN; -- not serial
+SELECT '9791234567896'::ISSN; -- not serial
+SELECT '0123456789012'::ISSN; -- not serial
+
+SELECT '9780123456786'::UPC; -- not a product
+SELECT '9771234567898'::UPC; -- not a product
+SELECT '9790123456785'::UPC; -- not a product
+SELECT '9791234567896'::UPC; -- not a product
+
+SELECT 'postgresql...'::EAN13;
+SELECT 'postgresql...'::ISBN;
+SELECT 9780123456786::EAN13;
+SELECT 9780123456786::ISBN;
+
+--
+-- test some comparisons, must yield true
+--
+SELECT '12345679'::ISSN = '9771234567003'::EAN13 AS "ok",
+       'M-1234-5678-5'::ISMN = '9790123456785'::EAN13 AS "ok",
+       '9791234567896'::EAN13 != '123456789X'::ISBN AS "nope";
+
+--
+-- cleanup
+--
+DROP EXTENSION isn;