From 501e7b5c1cf04162305c56e85204d2b1ac9427fb Mon Sep 17 00:00:00 2001 From: Chris Marchesi Date: Tue, 1 Sep 2026 12:05:27 -0700 Subject: [PATCH] pkg/fontconfig: update to 2.18.3 This updates our own bundled fontconfig (for static builds) to 2.18.3. Note that fontconfig has changed their build process a bit since this has been updated last; they are leaning on the Autoconf (and Meson as they are now deprecating use of Autoconf) toolchain(s) to now generate a number of headers that are a part of the build process. Since servicing this dependency in an effort to keep the build pure Zig is starting to get more complex, I've added some documentation on how to actually get a snapshot of the fontconfig repository in a state where files can be looked for and copied over as needed. Otherwise, we might want to in the future consider removing this altogether and just rely on system integrations. Co-Authored-By: Jeffrey C. Ollie --- build.zig.zon.json | 6 +- build.zig.zon.nix | 6 +- build.zig.zon.txt | 2 +- flatpak/zig-packages.json | 6 +- pkg/fontconfig/build.zig | 91 +- pkg/fontconfig/build.zig.zon | 4 +- pkg/fontconfig/override/fc-case/fccase.h | 354 + pkg/fontconfig/override/fc-const/fcconst.h | 700 ++ .../fc-genericfamily/fcgenericfamily.h | 6963 +++++++++++++++++ pkg/fontconfig/override/fc-lang/fclang.h | 5586 +++++++++++++ .../override/fontconfig/fontconfig.h | 1245 +++ pkg/fontconfig/override/include/fcalias.h | 0 pkg/fontconfig/override/include/fcaliastail.h | 0 pkg/fontconfig/override/include/fcftalias.h | 0 .../override/include/fcftaliastail.h | 0 pkg/fontconfig/override/src/fcalias.h | 472 ++ pkg/fontconfig/override/src/fcaliastail.h | 528 ++ pkg/fontconfig/override/src/fcftalias.h | 16 + pkg/fontconfig/override/src/fcftaliastail.h | 24 + pkg/fontconfig/override/src/fcint.h | 1752 +++++ .../override/{include => src}/fcobjshash.h | 454 +- pkg/fontconfig/override/src/fcstdint.h | 9 + 22 files changed, 17985 insertions(+), 233 deletions(-) create mode 100644 pkg/fontconfig/override/fc-case/fccase.h create mode 100644 pkg/fontconfig/override/fc-const/fcconst.h create mode 100644 pkg/fontconfig/override/fc-genericfamily/fcgenericfamily.h create mode 100644 pkg/fontconfig/override/fc-lang/fclang.h create mode 100644 pkg/fontconfig/override/fontconfig/fontconfig.h delete mode 100644 pkg/fontconfig/override/include/fcalias.h delete mode 100644 pkg/fontconfig/override/include/fcaliastail.h delete mode 100644 pkg/fontconfig/override/include/fcftalias.h delete mode 100644 pkg/fontconfig/override/include/fcftaliastail.h create mode 100644 pkg/fontconfig/override/src/fcalias.h create mode 100644 pkg/fontconfig/override/src/fcaliastail.h create mode 100644 pkg/fontconfig/override/src/fcftalias.h create mode 100644 pkg/fontconfig/override/src/fcftaliastail.h create mode 100644 pkg/fontconfig/override/src/fcint.h rename pkg/fontconfig/override/{include => src}/fcobjshash.h (53%) create mode 100644 pkg/fontconfig/override/src/fcstdint.h diff --git a/build.zig.zon.json b/build.zig.zon.json index e3d3b205a..9ad452d32 100644 --- a/build.zig.zon.json +++ b/build.zig.zon.json @@ -14,10 +14,10 @@ "url": "https://deps.files.ghostty.org/breakpad-b99f444ba5f6b98cac261cbb391d8766b34a5918.tar.gz", "hash": "sha256-bMqYlD0amQdmzvYQd8Ca/1k4Bj/heh7+EijlQSttatk=" }, - "N-V-__8AAIrfdwARSa-zMmxWwFuwpXf1T3asIN7s5jqi9c1v": { + "N-V-__8AAOgqbADacob-q2_DMQlmgaG4xKHRuW-6PJ4oJzMZ": { "name": "fontconfig", - "url": "https://deps.files.ghostty.org/fontconfig-2.14.2.tar.gz", - "hash": "sha256-O6LdkhWHGKzsXKrxpxYEO1qgVcJ7CB2RSvPMtA3OilU=" + "url": "https://gitlab.freedesktop.org/api/v4/projects/890/packages/generic/fontconfig/2.18.3/fontconfig-2.18.3.tar.xz", + "hash": "sha256-T3tVSjjN94wDP2ZsiHHzdJ4UoJT2Wgf2MMke0LQ9NeM=" }, "N-V-__8AAKLKpwC4H27Ps_0iL3bPkQb-z6ZVSrB-x_3EEkub": { "name": "freetype", diff --git a/build.zig.zon.nix b/build.zig.zon.nix index 58ce3fda6..37071a76a 100644 --- a/build.zig.zon.nix +++ b/build.zig.zon.nix @@ -125,11 +125,11 @@ in }; } { - name = "N-V-__8AAIrfdwARSa-zMmxWwFuwpXf1T3asIN7s5jqi9c1v"; + name = "N-V-__8AAOgqbADacob-q2_DMQlmgaG4xKHRuW-6PJ4oJzMZ"; path = fetchZigArtifact { name = "fontconfig"; - url = "https://deps.files.ghostty.org/fontconfig-2.14.2.tar.gz"; - hash = "sha256-O6LdkhWHGKzsXKrxpxYEO1qgVcJ7CB2RSvPMtA3OilU="; + url = "https://gitlab.freedesktop.org/api/v4/projects/890/packages/generic/fontconfig/2.18.3/fontconfig-2.18.3.tar.xz"; + hash = "sha256-T3tVSjjN94wDP2ZsiHHzdJ4UoJT2Wgf2MMke0LQ9NeM="; unpack = false; }; } diff --git a/build.zig.zon.txt b/build.zig.zon.txt index 77df51c0b..d44c8465a 100644 --- a/build.zig.zon.txt +++ b/build.zig.zon.txt @@ -6,7 +6,6 @@ https://deps.files.ghostty.org/N-V-__8AAEbOfQBnvcFcCX2W5z7tDaN8vaNZGamEQtNOe0UI. https://deps.files.ghostty.org/N-V-__8AAFdWDwA0ktbNUi9pFBHCRN4weXIgIfCrVjfGxqgA.tar.gz https://deps.files.ghostty.org/NerdFontsSymbolsOnly-3.4.0.tar.gz https://deps.files.ghostty.org/breakpad-b99f444ba5f6b98cac261cbb391d8766b34a5918.tar.gz -https://deps.files.ghostty.org/fontconfig-2.14.2.tar.gz https://deps.files.ghostty.org/freetype-1220b81f6ecfb3fd222f76cf9106fecfa6554ab07ec7fdc4124b9bb063ae2adf969d.tar.gz https://deps.files.ghostty.org/gettext-0.24.tar.gz https://deps.files.ghostty.org/ghostty-themes-release-20260824-153547-75c93ee.tgz @@ -36,3 +35,4 @@ https://deps.files.ghostty.org/zig_js-3c23860e47fdcdc5af805efb7fd0bdac5fd3e9bc.t https://deps.files.ghostty.org/zig_objc-c8de82ff80281215ad92900866dab7103a8efa8b.tar.gz https://deps.files.ghostty.org/zlib-1220fed0c74e1019b3ee29edae2051788b080cd96e90d56836eea857b0b966742efb.tar.gz https://github.com/vancluever/arocc/archive/ecbc5c799574e0da2758a961b12efa586007f03c.tar.gz +https://gitlab.freedesktop.org/api/v4/projects/890/packages/generic/fontconfig/2.18.3/fontconfig-2.18.3.tar.xz diff --git a/flatpak/zig-packages.json b/flatpak/zig-packages.json index 4c9fb5cf8..c072311f6 100644 --- a/flatpak/zig-packages.json +++ b/flatpak/zig-packages.json @@ -19,9 +19,9 @@ }, { "type": "archive", - "url": "https://deps.files.ghostty.org/fontconfig-2.14.2.tar.gz", - "dest": "vendor/p/N-V-__8AAIrfdwARSa-zMmxWwFuwpXf1T3asIN7s5jqi9c1v", - "sha256": "3ba2dd92158718acec5caaf1a716043b5aa055c27b081d914af3ccb40dce8a55" + "url": "https://gitlab.freedesktop.org/api/v4/projects/890/packages/generic/fontconfig/2.18.3/fontconfig-2.18.3.tar.xz", + "dest": "vendor/p/N-V-__8AAOgqbADacob-q2_DMQlmgaG4xKHRuW-6PJ4oJzMZ", + "sha256": "4f7b554a38cdf78c033f666c8871f3749e14a094f65a07f630c91ed0b43d35e3" }, { "type": "archive", diff --git a/pkg/fontconfig/build.zig b/pkg/fontconfig/build.zig index cd507454f..a1f43eac7 100644 --- a/pkg/fontconfig/build.zig +++ b/pkg/fontconfig/build.zig @@ -1,6 +1,49 @@ const std = @import("std"); +const build_zon = @import("build.zig.zon"); const NativeTargetInfo = std.zig.system.NativeTargetInfo; +// NOTE: This build is becoming more and more complex; we need to continually +// extract the correct options from fontconfig build process (although this +// part has been reasonably manageable for now); more concerning is the fact +// that we also need to now extract more generated files as fontconfig is +// leaning on generation more during their own Autoconf/Meson toolchain. +// Additionally, the Autoconf process (which incidentally is what Nix uses as +// well) has been deprecated since 2.18.3 (based on tracking the contents of +// the INSTALL file), which means we will need to lean on Meson more and more +// for this data. +// +// For now, autoconf still seems to work and can get us the files we need. +// +// If this build fails for any reason during update, you will need to inspect +// the build logs and extract any possible missing headers. These can be +// fetched through the following: +// +// * Set yourself up a Nix flake or build environment otherwise with the +// following deps (note: these were extracted from the Nix package itself): +// +// autoconf +// automake +// expat +// freetype +// gettext +// gperf +// libtool +// libxslt +// pkg-config +// python3 +// +// * Fetch the fontconfig source and extract it in this environment. +// +// * In the source root, run "./autogen.sh" followed by "make". (Don't run +// "make install"). +// +// * You should now have a reasonable set of files that you can use to hunt for +// any missing auto-generated headers and plumb through errors otherwise. +// +// * Make sure when you copy includes and what not into the "override" tree, +// that you preserve directory structure. This will help us keep track of what +// we need and where it specifically came from. + pub fn build(b: *std.Build) !void { const target = b.standardTargetOptions(.{}); const optimize = b.standardOptimizeOption(.{}); @@ -82,11 +125,32 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu lib.root_module.linkSystemLibrary("pthread", dynamic_link_opts); } - lib.root_module.addIncludePath(b.path("override/include")); - module.addIncludePath(b.path("override/include")); + // NOTE: The following directories are present in override but don't need + // to be added here: + // + // override/fc-case + // + inline for (.{ + "override", + "override/fc-const", + "override/fc-genericfamily", + "override/fc-lang", + "override/src", + }) |override_dir| { + lib.root_module.addIncludePath(b.path(override_dir)); + module.addIncludePath(b.path(override_dir)); + } var flags: std.ArrayList([]const u8) = .empty; defer flags.deinit(b.allocator); + + const version = try std.SemanticVersion.parse(build_zon.version); + try flags.appendSlice(b.allocator, &.{ + b.fmt("-DFC_VERSION_MAJOR={d}", .{version.major}), + b.fmt("-DFC_VERSION_MINOR={d}", .{version.minor}), + b.fmt("-DFC_VERSION_MICRO={d}", .{version.patch}), + }); + try flags.appendSlice(b.allocator, &.{ "-DHAVE_DIRENT_H", "-DHAVE_FCNTL_H", @@ -101,6 +165,7 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu "-DHAVE_RAND", //"-DHAVE_RANDOM_R", "-DHAVE_VPRINTF", + "-DHAVE_VSNPRINTF", "-DHAVE_FT_GET_BDF_PROPERTY", "-DHAVE_FT_GET_PS_FONT_INFO", @@ -168,6 +233,7 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu "-DHAVE_RANDOM", "-DHAVE_RAND_R", "-DHAVE_READLINK", + "-DHAVE_USELOCALE", "-DHAVE_SYS_MOUNT_H", "-DHAVE_SYS_STATVFS_H", @@ -200,6 +266,8 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu // Freetype2 _ = b.systemIntegrationOption("freetype", .{}); // So it shows up in help if (freetype_enabled) { + // Value-tested (#if/#elif) by upstream so it must be =1. + try flags.append(b.allocator, "-DENABLE_FREETYPE=1"); if (b.systemIntegrationOption("freetype", .{})) { lib.root_module.linkSystemLibrary("freetype2", dynamic_link_opts); } else { @@ -254,6 +322,18 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu "fontconfig", .{ .include_extensions = &.{".h"} }, ); + + // Upstream only ships fontconfig.h.in; we generate fontconfig.h into + // our override directory. + // + // TODO: I'm not too sure if this is fully needed - testing the build + // with both system integration on and off seems to be not break with + // this missing (and for that matter, all of the header install stuff + // we do, funny enough). + lib.installHeader( + b.path("override/fontconfig/fontconfig.h"), + "fontconfig/fontconfig.h", + ); } b.installArtifact(lib); @@ -261,12 +341,6 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu return lib; } -const headers = &.{ - "fontconfig/fontconfig.h", - "fontconfig/fcprivate.h", - "fontconfig/fcfreetype.h", -}; - const srcs: []const []const u8 = &.{ "src/fcatomic.c", "src/fccache.c", @@ -279,6 +353,7 @@ const srcs: []const []const u8 = &.{ "src/fcformat.c", "src/fcfreetype.c", "src/fcfs.c", + "src/fcgenericalias.c", "src/fcptrlist.c", "src/fchash.c", "src/fcinit.c", diff --git a/pkg/fontconfig/build.zig.zon b/pkg/fontconfig/build.zig.zon index b1387b87e..5249219c6 100644 --- a/pkg/fontconfig/build.zig.zon +++ b/pkg/fontconfig/build.zig.zon @@ -5,8 +5,8 @@ .paths = .{""}, .dependencies = .{ .fontconfig = .{ - .url = "https://deps.files.ghostty.org/fontconfig-2.14.2.tar.gz", - .hash = "N-V-__8AAIrfdwARSa-zMmxWwFuwpXf1T3asIN7s5jqi9c1v", + .url = "https://gitlab.freedesktop.org/api/v4/projects/890/packages/generic/fontconfig/2.18.3/fontconfig-2.18.3.tar.xz", + .hash = "N-V-__8AAOgqbADacob-q2_DMQlmgaG4xKHRuW-6PJ4oJzMZ", .lazy = true, }, diff --git a/pkg/fontconfig/override/fc-case/fccase.h b/pkg/fontconfig/override/fc-case/fccase.h new file mode 100644 index 000000000..68d019cea --- /dev/null +++ b/pkg/fontconfig/override/fc-case/fccase.h @@ -0,0 +1,354 @@ +/* + * This file was generated against CaseFolding.txt from Unicode.org. + * All the data in array is a part of them and licensed under a terms of use: + * https://www.unicode.org/terms_of_use.html + */ + +#define FC_NUM_CASE_FOLD 306 +#define FC_NUM_CASE_FOLD_CHARS 471 +#define FC_MAX_CASE_FOLD_CHARS 6 +#define FC_MAX_CASE_FOLD_EXPAND 4 +#define FC_MIN_FOLD_CHAR 0x00000041 +#define FC_MAX_FOLD_CHAR 0x0001e921 + +static const FcCaseFold fcCaseFold[FC_NUM_CASE_FOLD] = { + { 0x00000041, FC_CASE_FOLD_RANGE, 0x001a, 32 }, + { 0x000000b5, FC_CASE_FOLD_RANGE, 0x0001, 775 }, + { 0x000000c0, FC_CASE_FOLD_RANGE, 0x0017, 32 }, + { 0x000000d8, FC_CASE_FOLD_RANGE, 0x0007, 32 }, + { 0x000000df, FC_CASE_FOLD_FULL, 0x0002, 0 }, + { 0x00000100, FC_CASE_FOLD_EVEN_ODD, 0x002f, 1 }, + { 0x00000130, FC_CASE_FOLD_FULL, 0x0003, 2 }, + { 0x00000132, FC_CASE_FOLD_EVEN_ODD, 0x0005, 1 }, + { 0x00000139, FC_CASE_FOLD_EVEN_ODD, 0x000f, 1 }, + { 0x00000149, FC_CASE_FOLD_FULL, 0x0003, 5 }, + { 0x0000014a, FC_CASE_FOLD_EVEN_ODD, 0x002d, 1 }, + { 0x00000178, FC_CASE_FOLD_RANGE, 0x0001, -121 }, + { 0x00000179, FC_CASE_FOLD_EVEN_ODD, 0x0005, 1 }, + { 0x0000017f, FC_CASE_FOLD_RANGE, 0x0001, -268 }, + { 0x00000181, FC_CASE_FOLD_RANGE, 0x0001, 210 }, + { 0x00000182, FC_CASE_FOLD_EVEN_ODD, 0x0003, 1 }, + { 0x00000186, FC_CASE_FOLD_RANGE, 0x0001, 206 }, + { 0x00000187, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x00000189, FC_CASE_FOLD_RANGE, 0x0002, 205 }, + { 0x0000018b, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x0000018e, FC_CASE_FOLD_RANGE, 0x0001, 79 }, + { 0x0000018f, FC_CASE_FOLD_RANGE, 0x0001, 202 }, + { 0x00000190, FC_CASE_FOLD_RANGE, 0x0001, 203 }, + { 0x00000191, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x00000193, FC_CASE_FOLD_RANGE, 0x0001, 205 }, + { 0x00000194, FC_CASE_FOLD_RANGE, 0x0001, 207 }, + { 0x00000196, FC_CASE_FOLD_RANGE, 0x0001, 211 }, + { 0x00000197, FC_CASE_FOLD_RANGE, 0x0001, 209 }, + { 0x00000198, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x0000019c, FC_CASE_FOLD_RANGE, 0x0001, 211 }, + { 0x0000019d, FC_CASE_FOLD_RANGE, 0x0001, 213 }, + { 0x0000019f, FC_CASE_FOLD_RANGE, 0x0001, 214 }, + { 0x000001a0, FC_CASE_FOLD_EVEN_ODD, 0x0005, 1 }, + { 0x000001a6, FC_CASE_FOLD_RANGE, 0x0001, 218 }, + { 0x000001a7, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x000001a9, FC_CASE_FOLD_RANGE, 0x0001, 218 }, + { 0x000001ac, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x000001ae, FC_CASE_FOLD_RANGE, 0x0001, 218 }, + { 0x000001af, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x000001b1, FC_CASE_FOLD_RANGE, 0x0002, 217 }, + { 0x000001b3, FC_CASE_FOLD_EVEN_ODD, 0x0003, 1 }, + { 0x000001b7, FC_CASE_FOLD_RANGE, 0x0001, 219 }, + { 0x000001b8, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x000001bc, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x000001c4, FC_CASE_FOLD_RANGE, 0x0001, 2 }, + { 0x000001c5, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x000001c7, FC_CASE_FOLD_RANGE, 0x0001, 2 }, + { 0x000001c8, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x000001ca, FC_CASE_FOLD_RANGE, 0x0001, 2 }, + { 0x000001cb, FC_CASE_FOLD_EVEN_ODD, 0x0011, 1 }, + { 0x000001de, FC_CASE_FOLD_EVEN_ODD, 0x0011, 1 }, + { 0x000001f0, FC_CASE_FOLD_FULL, 0x0003, 8 }, + { 0x000001f1, FC_CASE_FOLD_RANGE, 0x0001, 2 }, + { 0x000001f2, FC_CASE_FOLD_EVEN_ODD, 0x0003, 1 }, + { 0x000001f6, FC_CASE_FOLD_RANGE, 0x0001, -97 }, + { 0x000001f7, FC_CASE_FOLD_RANGE, 0x0001, -56 }, + { 0x000001f8, FC_CASE_FOLD_EVEN_ODD, 0x0027, 1 }, + { 0x00000220, FC_CASE_FOLD_RANGE, 0x0001, -130 }, + { 0x00000222, FC_CASE_FOLD_EVEN_ODD, 0x0011, 1 }, + { 0x0000023a, FC_CASE_FOLD_RANGE, 0x0001, 10795 }, + { 0x0000023b, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x0000023d, FC_CASE_FOLD_RANGE, 0x0001, -163 }, + { 0x0000023e, FC_CASE_FOLD_RANGE, 0x0001, 10792 }, + { 0x00000241, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x00000243, FC_CASE_FOLD_RANGE, 0x0001, -195 }, + { 0x00000244, FC_CASE_FOLD_RANGE, 0x0001, 69 }, + { 0x00000245, FC_CASE_FOLD_RANGE, 0x0001, 71 }, + { 0x00000246, FC_CASE_FOLD_EVEN_ODD, 0x0009, 1 }, + { 0x00000345, FC_CASE_FOLD_RANGE, 0x0001, 116 }, + { 0x00000370, FC_CASE_FOLD_EVEN_ODD, 0x0003, 1 }, + { 0x00000376, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x0000037f, FC_CASE_FOLD_RANGE, 0x0001, 116 }, + { 0x00000386, FC_CASE_FOLD_RANGE, 0x0001, 38 }, + { 0x00000388, FC_CASE_FOLD_RANGE, 0x0003, 37 }, + { 0x0000038c, FC_CASE_FOLD_RANGE, 0x0001, 64 }, + { 0x0000038e, FC_CASE_FOLD_RANGE, 0x0002, 63 }, + { 0x00000390, FC_CASE_FOLD_FULL, 0x0006, 11 }, + { 0x00000391, FC_CASE_FOLD_RANGE, 0x0011, 32 }, + { 0x000003a3, FC_CASE_FOLD_RANGE, 0x0009, 32 }, + { 0x000003b0, FC_CASE_FOLD_FULL, 0x0006, 17 }, + { 0x000003c2, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x000003cf, FC_CASE_FOLD_RANGE, 0x0001, 8 }, + { 0x000003d0, FC_CASE_FOLD_RANGE, 0x0001, -30 }, + { 0x000003d1, FC_CASE_FOLD_RANGE, 0x0001, -25 }, + { 0x000003d5, FC_CASE_FOLD_RANGE, 0x0001, -15 }, + { 0x000003d6, FC_CASE_FOLD_RANGE, 0x0001, -22 }, + { 0x000003d8, FC_CASE_FOLD_EVEN_ODD, 0x0017, 1 }, + { 0x000003f0, FC_CASE_FOLD_RANGE, 0x0001, -54 }, + { 0x000003f1, FC_CASE_FOLD_RANGE, 0x0001, -48 }, + { 0x000003f4, FC_CASE_FOLD_RANGE, 0x0001, -60 }, + { 0x000003f5, FC_CASE_FOLD_RANGE, 0x0001, -64 }, + { 0x000003f7, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x000003f9, FC_CASE_FOLD_RANGE, 0x0001, -7 }, + { 0x000003fa, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x000003fd, FC_CASE_FOLD_RANGE, 0x0003, -130 }, + { 0x00000400, FC_CASE_FOLD_RANGE, 0x0010, 80 }, + { 0x00000410, FC_CASE_FOLD_RANGE, 0x0020, 32 }, + { 0x00000460, FC_CASE_FOLD_EVEN_ODD, 0x0021, 1 }, + { 0x0000048a, FC_CASE_FOLD_EVEN_ODD, 0x0035, 1 }, + { 0x000004c0, FC_CASE_FOLD_RANGE, 0x0001, 15 }, + { 0x000004c1, FC_CASE_FOLD_EVEN_ODD, 0x000d, 1 }, + { 0x000004d0, FC_CASE_FOLD_EVEN_ODD, 0x005f, 1 }, + { 0x00000531, FC_CASE_FOLD_RANGE, 0x0026, 48 }, + { 0x00000587, FC_CASE_FOLD_FULL, 0x0004, 23 }, + { 0x000010a0, FC_CASE_FOLD_RANGE, 0x0026, 7264 }, + { 0x000010c7, FC_CASE_FOLD_RANGE, 0x0001, 7264 }, + { 0x000010cd, FC_CASE_FOLD_RANGE, 0x0001, 7264 }, + { 0x000013f8, FC_CASE_FOLD_RANGE, 0x0006, -8 }, + { 0x00001c80, FC_CASE_FOLD_RANGE, 0x0001, -6222 }, + { 0x00001c81, FC_CASE_FOLD_RANGE, 0x0001, -6221 }, + { 0x00001c82, FC_CASE_FOLD_RANGE, 0x0001, -6212 }, + { 0x00001c83, FC_CASE_FOLD_RANGE, 0x0002, -6210 }, + { 0x00001c85, FC_CASE_FOLD_RANGE, 0x0001, -6211 }, + { 0x00001c86, FC_CASE_FOLD_RANGE, 0x0001, -6204 }, + { 0x00001c87, FC_CASE_FOLD_RANGE, 0x0001, -6180 }, + { 0x00001c88, FC_CASE_FOLD_RANGE, 0x0001, -30269 }, + { 0x00001c89, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x00001c90, FC_CASE_FOLD_RANGE, 0x002b, -3008 }, + { 0x00001cbd, FC_CASE_FOLD_RANGE, 0x0003, -3008 }, + { 0x00001e00, FC_CASE_FOLD_EVEN_ODD, 0x0095, 1 }, + { 0x00001e96, FC_CASE_FOLD_FULL, 0x0003, 27 }, + { 0x00001e97, FC_CASE_FOLD_FULL, 0x0003, 30 }, + { 0x00001e98, FC_CASE_FOLD_FULL, 0x0003, 33 }, + { 0x00001e99, FC_CASE_FOLD_FULL, 0x0003, 36 }, + { 0x00001e9a, FC_CASE_FOLD_FULL, 0x0003, 39 }, + { 0x00001e9b, FC_CASE_FOLD_RANGE, 0x0001, -58 }, + { 0x00001e9e, FC_CASE_FOLD_FULL, 0x0002, 42 }, + { 0x00001ea0, FC_CASE_FOLD_EVEN_ODD, 0x005f, 1 }, + { 0x00001f08, FC_CASE_FOLD_RANGE, 0x0008, -8 }, + { 0x00001f18, FC_CASE_FOLD_RANGE, 0x0006, -8 }, + { 0x00001f28, FC_CASE_FOLD_RANGE, 0x0008, -8 }, + { 0x00001f38, FC_CASE_FOLD_RANGE, 0x0008, -8 }, + { 0x00001f48, FC_CASE_FOLD_RANGE, 0x0006, -8 }, + { 0x00001f50, FC_CASE_FOLD_FULL, 0x0004, 44 }, + { 0x00001f52, FC_CASE_FOLD_FULL, 0x0006, 48 }, + { 0x00001f54, FC_CASE_FOLD_FULL, 0x0006, 54 }, + { 0x00001f56, FC_CASE_FOLD_FULL, 0x0006, 60 }, + { 0x00001f59, FC_CASE_FOLD_RANGE, 0x0001, -8 }, + { 0x00001f5b, FC_CASE_FOLD_RANGE, 0x0001, -8 }, + { 0x00001f5d, FC_CASE_FOLD_RANGE, 0x0001, -8 }, + { 0x00001f5f, FC_CASE_FOLD_RANGE, 0x0001, -8 }, + { 0x00001f68, FC_CASE_FOLD_RANGE, 0x0008, -8 }, + { 0x00001f80, FC_CASE_FOLD_FULL, 0x0005, 66 }, + { 0x00001f81, FC_CASE_FOLD_FULL, 0x0005, 71 }, + { 0x00001f82, FC_CASE_FOLD_FULL, 0x0005, 76 }, + { 0x00001f83, FC_CASE_FOLD_FULL, 0x0005, 81 }, + { 0x00001f84, FC_CASE_FOLD_FULL, 0x0005, 86 }, + { 0x00001f85, FC_CASE_FOLD_FULL, 0x0005, 91 }, + { 0x00001f86, FC_CASE_FOLD_FULL, 0x0005, 96 }, + { 0x00001f87, FC_CASE_FOLD_FULL, 0x0005, 101 }, + { 0x00001f88, FC_CASE_FOLD_FULL, 0x0005, 106 }, + { 0x00001f89, FC_CASE_FOLD_FULL, 0x0005, 111 }, + { 0x00001f8a, FC_CASE_FOLD_FULL, 0x0005, 116 }, + { 0x00001f8b, FC_CASE_FOLD_FULL, 0x0005, 121 }, + { 0x00001f8c, FC_CASE_FOLD_FULL, 0x0005, 126 }, + { 0x00001f8d, FC_CASE_FOLD_FULL, 0x0005, 131 }, + { 0x00001f8e, FC_CASE_FOLD_FULL, 0x0005, 136 }, + { 0x00001f8f, FC_CASE_FOLD_FULL, 0x0005, 141 }, + { 0x00001f90, FC_CASE_FOLD_FULL, 0x0005, 146 }, + { 0x00001f91, FC_CASE_FOLD_FULL, 0x0005, 151 }, + { 0x00001f92, FC_CASE_FOLD_FULL, 0x0005, 156 }, + { 0x00001f93, FC_CASE_FOLD_FULL, 0x0005, 161 }, + { 0x00001f94, FC_CASE_FOLD_FULL, 0x0005, 166 }, + { 0x00001f95, FC_CASE_FOLD_FULL, 0x0005, 171 }, + { 0x00001f96, FC_CASE_FOLD_FULL, 0x0005, 176 }, + { 0x00001f97, FC_CASE_FOLD_FULL, 0x0005, 181 }, + { 0x00001f98, FC_CASE_FOLD_FULL, 0x0005, 186 }, + { 0x00001f99, FC_CASE_FOLD_FULL, 0x0005, 191 }, + { 0x00001f9a, FC_CASE_FOLD_FULL, 0x0005, 196 }, + { 0x00001f9b, FC_CASE_FOLD_FULL, 0x0005, 201 }, + { 0x00001f9c, FC_CASE_FOLD_FULL, 0x0005, 206 }, + { 0x00001f9d, FC_CASE_FOLD_FULL, 0x0005, 211 }, + { 0x00001f9e, FC_CASE_FOLD_FULL, 0x0005, 216 }, + { 0x00001f9f, FC_CASE_FOLD_FULL, 0x0005, 221 }, + { 0x00001fa0, FC_CASE_FOLD_FULL, 0x0005, 226 }, + { 0x00001fa1, FC_CASE_FOLD_FULL, 0x0005, 231 }, + { 0x00001fa2, FC_CASE_FOLD_FULL, 0x0005, 236 }, + { 0x00001fa3, FC_CASE_FOLD_FULL, 0x0005, 241 }, + { 0x00001fa4, FC_CASE_FOLD_FULL, 0x0005, 246 }, + { 0x00001fa5, FC_CASE_FOLD_FULL, 0x0005, 251 }, + { 0x00001fa6, FC_CASE_FOLD_FULL, 0x0005, 256 }, + { 0x00001fa7, FC_CASE_FOLD_FULL, 0x0005, 261 }, + { 0x00001fa8, FC_CASE_FOLD_FULL, 0x0005, 266 }, + { 0x00001fa9, FC_CASE_FOLD_FULL, 0x0005, 271 }, + { 0x00001faa, FC_CASE_FOLD_FULL, 0x0005, 276 }, + { 0x00001fab, FC_CASE_FOLD_FULL, 0x0005, 281 }, + { 0x00001fac, FC_CASE_FOLD_FULL, 0x0005, 286 }, + { 0x00001fad, FC_CASE_FOLD_FULL, 0x0005, 291 }, + { 0x00001fae, FC_CASE_FOLD_FULL, 0x0005, 296 }, + { 0x00001faf, FC_CASE_FOLD_FULL, 0x0005, 301 }, + { 0x00001fb2, FC_CASE_FOLD_FULL, 0x0005, 306 }, + { 0x00001fb3, FC_CASE_FOLD_FULL, 0x0004, 311 }, + { 0x00001fb4, FC_CASE_FOLD_FULL, 0x0004, 315 }, + { 0x00001fb6, FC_CASE_FOLD_FULL, 0x0004, 319 }, + { 0x00001fb7, FC_CASE_FOLD_FULL, 0x0006, 323 }, + { 0x00001fb8, FC_CASE_FOLD_RANGE, 0x0002, -8 }, + { 0x00001fba, FC_CASE_FOLD_RANGE, 0x0002, -74 }, + { 0x00001fbc, FC_CASE_FOLD_FULL, 0x0004, 329 }, + { 0x00001fbe, FC_CASE_FOLD_RANGE, 0x0001, -7173 }, + { 0x00001fc2, FC_CASE_FOLD_FULL, 0x0005, 333 }, + { 0x00001fc3, FC_CASE_FOLD_FULL, 0x0004, 338 }, + { 0x00001fc4, FC_CASE_FOLD_FULL, 0x0004, 342 }, + { 0x00001fc6, FC_CASE_FOLD_FULL, 0x0004, 346 }, + { 0x00001fc7, FC_CASE_FOLD_FULL, 0x0006, 350 }, + { 0x00001fc8, FC_CASE_FOLD_RANGE, 0x0004, -86 }, + { 0x00001fcc, FC_CASE_FOLD_FULL, 0x0004, 356 }, + { 0x00001fd2, FC_CASE_FOLD_FULL, 0x0006, 360 }, + { 0x00001fd3, FC_CASE_FOLD_FULL, 0x0006, 366 }, + { 0x00001fd6, FC_CASE_FOLD_FULL, 0x0004, 372 }, + { 0x00001fd7, FC_CASE_FOLD_FULL, 0x0006, 376 }, + { 0x00001fd8, FC_CASE_FOLD_RANGE, 0x0002, -8 }, + { 0x00001fda, FC_CASE_FOLD_RANGE, 0x0002, -100 }, + { 0x00001fe2, FC_CASE_FOLD_FULL, 0x0006, 382 }, + { 0x00001fe3, FC_CASE_FOLD_FULL, 0x0006, 388 }, + { 0x00001fe4, FC_CASE_FOLD_FULL, 0x0004, 394 }, + { 0x00001fe6, FC_CASE_FOLD_FULL, 0x0004, 398 }, + { 0x00001fe7, FC_CASE_FOLD_FULL, 0x0006, 402 }, + { 0x00001fe8, FC_CASE_FOLD_RANGE, 0x0002, -8 }, + { 0x00001fea, FC_CASE_FOLD_RANGE, 0x0002, -112 }, + { 0x00001fec, FC_CASE_FOLD_RANGE, 0x0001, -7 }, + { 0x00001ff2, FC_CASE_FOLD_FULL, 0x0005, 408 }, + { 0x00001ff3, FC_CASE_FOLD_FULL, 0x0004, 413 }, + { 0x00001ff4, FC_CASE_FOLD_FULL, 0x0004, 417 }, + { 0x00001ff6, FC_CASE_FOLD_FULL, 0x0004, 421 }, + { 0x00001ff7, FC_CASE_FOLD_FULL, 0x0006, 425 }, + { 0x00001ff8, FC_CASE_FOLD_RANGE, 0x0002, -128 }, + { 0x00001ffa, FC_CASE_FOLD_RANGE, 0x0002, -126 }, + { 0x00001ffc, FC_CASE_FOLD_FULL, 0x0004, 431 }, + { 0x00002126, FC_CASE_FOLD_RANGE, 0x0001, -7517 }, + { 0x0000212a, FC_CASE_FOLD_RANGE, 0x0001, -8383 }, + { 0x0000212b, FC_CASE_FOLD_RANGE, 0x0001, -8262 }, + { 0x00002132, FC_CASE_FOLD_RANGE, 0x0001, 28 }, + { 0x00002160, FC_CASE_FOLD_RANGE, 0x0010, 16 }, + { 0x00002183, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x000024b6, FC_CASE_FOLD_RANGE, 0x001a, 26 }, + { 0x00002c00, FC_CASE_FOLD_RANGE, 0x0030, 48 }, + { 0x00002c60, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x00002c62, FC_CASE_FOLD_RANGE, 0x0001, -10743 }, + { 0x00002c63, FC_CASE_FOLD_RANGE, 0x0001, -3814 }, + { 0x00002c64, FC_CASE_FOLD_RANGE, 0x0001, -10727 }, + { 0x00002c67, FC_CASE_FOLD_EVEN_ODD, 0x0005, 1 }, + { 0x00002c6d, FC_CASE_FOLD_RANGE, 0x0001, -10780 }, + { 0x00002c6e, FC_CASE_FOLD_RANGE, 0x0001, -10749 }, + { 0x00002c6f, FC_CASE_FOLD_RANGE, 0x0001, -10783 }, + { 0x00002c70, FC_CASE_FOLD_RANGE, 0x0001, -10782 }, + { 0x00002c72, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x00002c75, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x00002c7e, FC_CASE_FOLD_RANGE, 0x0002, -10815 }, + { 0x00002c80, FC_CASE_FOLD_EVEN_ODD, 0x0063, 1 }, + { 0x00002ceb, FC_CASE_FOLD_EVEN_ODD, 0x0003, 1 }, + { 0x00002cf2, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x0000a640, FC_CASE_FOLD_EVEN_ODD, 0x002d, 1 }, + { 0x0000a680, FC_CASE_FOLD_EVEN_ODD, 0x001b, 1 }, + { 0x0000a722, FC_CASE_FOLD_EVEN_ODD, 0x000d, 1 }, + { 0x0000a732, FC_CASE_FOLD_EVEN_ODD, 0x003d, 1 }, + { 0x0000a779, FC_CASE_FOLD_EVEN_ODD, 0x0003, 1 }, + { 0x0000a77d, FC_CASE_FOLD_RANGE, 0x0001, 30204 }, + { 0x0000a77e, FC_CASE_FOLD_EVEN_ODD, 0x0009, 1 }, + { 0x0000a78b, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x0000a78d, FC_CASE_FOLD_RANGE, 0x0001, 23256 }, + { 0x0000a790, FC_CASE_FOLD_EVEN_ODD, 0x0003, 1 }, + { 0x0000a796, FC_CASE_FOLD_EVEN_ODD, 0x0013, 1 }, + { 0x0000a7aa, FC_CASE_FOLD_RANGE, 0x0001, 23228 }, + { 0x0000a7ab, FC_CASE_FOLD_RANGE, 0x0001, 23217 }, + { 0x0000a7ac, FC_CASE_FOLD_RANGE, 0x0001, 23221 }, + { 0x0000a7ad, FC_CASE_FOLD_RANGE, 0x0001, 23231 }, + { 0x0000a7ae, FC_CASE_FOLD_RANGE, 0x0001, 23228 }, + { 0x0000a7b0, FC_CASE_FOLD_RANGE, 0x0001, 23278 }, + { 0x0000a7b1, FC_CASE_FOLD_RANGE, 0x0001, 23254 }, + { 0x0000a7b2, FC_CASE_FOLD_RANGE, 0x0001, 23275 }, + { 0x0000a7b3, FC_CASE_FOLD_RANGE, 0x0001, 928 }, + { 0x0000a7b4, FC_CASE_FOLD_EVEN_ODD, 0x000f, 1 }, + { 0x0000a7c4, FC_CASE_FOLD_RANGE, 0x0001, -48 }, + { 0x0000a7c5, FC_CASE_FOLD_RANGE, 0x0001, 23229 }, + { 0x0000a7c6, FC_CASE_FOLD_RANGE, 0x0001, 30152 }, + { 0x0000a7c7, FC_CASE_FOLD_EVEN_ODD, 0x0003, 1 }, + { 0x0000a7cb, FC_CASE_FOLD_RANGE, 0x0001, 23193 }, + { 0x0000a7cc, FC_CASE_FOLD_EVEN_ODD, 0x000f, 1 }, + { 0x0000a7dc, FC_CASE_FOLD_RANGE, 0x0001, 22975 }, + { 0x0000a7f5, FC_CASE_FOLD_EVEN_ODD, 0x0001, 1 }, + { 0x0000ab70, FC_CASE_FOLD_RANGE, 0x0050, 26672 }, + { 0x0000fb00, FC_CASE_FOLD_FULL, 0x0002, 435 }, + { 0x0000fb01, FC_CASE_FOLD_FULL, 0x0002, 437 }, + { 0x0000fb02, FC_CASE_FOLD_FULL, 0x0002, 439 }, + { 0x0000fb03, FC_CASE_FOLD_FULL, 0x0003, 441 }, + { 0x0000fb04, FC_CASE_FOLD_FULL, 0x0003, 444 }, + { 0x0000fb05, FC_CASE_FOLD_FULL, 0x0002, 447 }, + { 0x0000fb06, FC_CASE_FOLD_FULL, 0x0002, 449 }, + { 0x0000fb13, FC_CASE_FOLD_FULL, 0x0004, 451 }, + { 0x0000fb14, FC_CASE_FOLD_FULL, 0x0004, 455 }, + { 0x0000fb15, FC_CASE_FOLD_FULL, 0x0004, 459 }, + { 0x0000fb16, FC_CASE_FOLD_FULL, 0x0004, 463 }, + { 0x0000fb17, FC_CASE_FOLD_FULL, 0x0004, 467 }, + { 0x0000ff21, FC_CASE_FOLD_RANGE, 0x001a, 32 }, + { 0x00010400, FC_CASE_FOLD_RANGE, 0x0028, 40 }, + { 0x000104b0, FC_CASE_FOLD_RANGE, 0x0024, 40 }, + { 0x00010570, FC_CASE_FOLD_RANGE, 0x000b, 39 }, + { 0x0001057c, FC_CASE_FOLD_RANGE, 0x000f, 39 }, + { 0x0001058c, FC_CASE_FOLD_RANGE, 0x0007, 39 }, + { 0x00010594, FC_CASE_FOLD_RANGE, 0x0002, 39 }, + { 0x00010c80, FC_CASE_FOLD_RANGE, 0x0033, 64 }, + { 0x00010d50, FC_CASE_FOLD_RANGE, 0x0016, 32 }, + { 0x000118a0, FC_CASE_FOLD_RANGE, 0x0020, 32 }, + { 0x00016e40, FC_CASE_FOLD_RANGE, 0x0020, 32 }, + { 0x00016ea0, FC_CASE_FOLD_RANGE, 0x0019, 27 }, + { 0x0001e900, FC_CASE_FOLD_RANGE, 0x0022, 34 }, +}; + +static const FcChar8 fcCaseFoldChars[FC_NUM_CASE_FOLD_CHARS] = { +0x73,0x73,0x69,0xcc,0x87,0xca,0xbc,0x6e,0x6a,0xcc,0x8c,0xce,0xb9,0xcc,0x88,0xcc, +0x81,0xcf,0x85,0xcc,0x88,0xcc,0x81,0xd5,0xa5,0xd6,0x82,0x68,0xcc,0xb1,0x74,0xcc, +0x88,0x77,0xcc,0x8a,0x79,0xcc,0x8a,0x61,0xca,0xbe,0x73,0x73,0xcf,0x85,0xcc,0x93, +0xcf,0x85,0xcc,0x93,0xcc,0x80,0xcf,0x85,0xcc,0x93,0xcc,0x81,0xcf,0x85,0xcc,0x93, +0xcd,0x82,0xe1,0xbc,0x80,0xce,0xb9,0xe1,0xbc,0x81,0xce,0xb9,0xe1,0xbc,0x82,0xce, +0xb9,0xe1,0xbc,0x83,0xce,0xb9,0xe1,0xbc,0x84,0xce,0xb9,0xe1,0xbc,0x85,0xce,0xb9, +0xe1,0xbc,0x86,0xce,0xb9,0xe1,0xbc,0x87,0xce,0xb9,0xe1,0xbc,0x80,0xce,0xb9,0xe1, +0xbc,0x81,0xce,0xb9,0xe1,0xbc,0x82,0xce,0xb9,0xe1,0xbc,0x83,0xce,0xb9,0xe1,0xbc, +0x84,0xce,0xb9,0xe1,0xbc,0x85,0xce,0xb9,0xe1,0xbc,0x86,0xce,0xb9,0xe1,0xbc,0x87, +0xce,0xb9,0xe1,0xbc,0xa0,0xce,0xb9,0xe1,0xbc,0xa1,0xce,0xb9,0xe1,0xbc,0xa2,0xce, +0xb9,0xe1,0xbc,0xa3,0xce,0xb9,0xe1,0xbc,0xa4,0xce,0xb9,0xe1,0xbc,0xa5,0xce,0xb9, +0xe1,0xbc,0xa6,0xce,0xb9,0xe1,0xbc,0xa7,0xce,0xb9,0xe1,0xbc,0xa0,0xce,0xb9,0xe1, +0xbc,0xa1,0xce,0xb9,0xe1,0xbc,0xa2,0xce,0xb9,0xe1,0xbc,0xa3,0xce,0xb9,0xe1,0xbc, +0xa4,0xce,0xb9,0xe1,0xbc,0xa5,0xce,0xb9,0xe1,0xbc,0xa6,0xce,0xb9,0xe1,0xbc,0xa7, +0xce,0xb9,0xe1,0xbd,0xa0,0xce,0xb9,0xe1,0xbd,0xa1,0xce,0xb9,0xe1,0xbd,0xa2,0xce, +0xb9,0xe1,0xbd,0xa3,0xce,0xb9,0xe1,0xbd,0xa4,0xce,0xb9,0xe1,0xbd,0xa5,0xce,0xb9, +0xe1,0xbd,0xa6,0xce,0xb9,0xe1,0xbd,0xa7,0xce,0xb9,0xe1,0xbd,0xa0,0xce,0xb9,0xe1, +0xbd,0xa1,0xce,0xb9,0xe1,0xbd,0xa2,0xce,0xb9,0xe1,0xbd,0xa3,0xce,0xb9,0xe1,0xbd, +0xa4,0xce,0xb9,0xe1,0xbd,0xa5,0xce,0xb9,0xe1,0xbd,0xa6,0xce,0xb9,0xe1,0xbd,0xa7, +0xce,0xb9,0xe1,0xbd,0xb0,0xce,0xb9,0xce,0xb1,0xce,0xb9,0xce,0xac,0xce,0xb9,0xce, +0xb1,0xcd,0x82,0xce,0xb1,0xcd,0x82,0xce,0xb9,0xce,0xb1,0xce,0xb9,0xe1,0xbd,0xb4, +0xce,0xb9,0xce,0xb7,0xce,0xb9,0xce,0xae,0xce,0xb9,0xce,0xb7,0xcd,0x82,0xce,0xb7, +0xcd,0x82,0xce,0xb9,0xce,0xb7,0xce,0xb9,0xce,0xb9,0xcc,0x88,0xcc,0x80,0xce,0xb9, +0xcc,0x88,0xcc,0x81,0xce,0xb9,0xcd,0x82,0xce,0xb9,0xcc,0x88,0xcd,0x82,0xcf,0x85, +0xcc,0x88,0xcc,0x80,0xcf,0x85,0xcc,0x88,0xcc,0x81,0xcf,0x81,0xcc,0x93,0xcf,0x85, +0xcd,0x82,0xcf,0x85,0xcc,0x88,0xcd,0x82,0xe1,0xbd,0xbc,0xce,0xb9,0xcf,0x89,0xce, +0xb9,0xcf,0x8e,0xce,0xb9,0xcf,0x89,0xcd,0x82,0xcf,0x89,0xcd,0x82,0xce,0xb9,0xcf, +0x89,0xce,0xb9,0x66,0x66,0x66,0x69,0x66,0x6c,0x66,0x66,0x69,0x66,0x66,0x6c,0x73, +0x74,0x73,0x74,0xd5,0xb4,0xd5,0xb6,0xd5,0xb4,0xd5,0xa5,0xd5,0xb4,0xd5,0xab,0xd5, +0xbe,0xd5,0xb6,0xd5,0xb4,0xd5,0xad +}; diff --git a/pkg/fontconfig/override/fc-const/fcconst.h b/pkg/fontconfig/override/fc-const/fcconst.h new file mode 100644 index 000000000..d0f9dce00 --- /dev/null +++ b/pkg/fontconfig/override/fc-const/fcconst.h @@ -0,0 +1,700 @@ +/* Copyright (C) 2025 fontconfig Authors */ +/* SPDX-License-Identifier: HPND */ + +typedef struct _FcConstIndex { + FcObject object; + int idx_obj; + int idx_variant; +} FcConstIndex; + +typedef struct _FcConstSymbolMap { + const FcChar8 *name; + FcConstIndex values[3]; +} FcConstSymbolMap; + +static const FcConstSymbolMap _FcBaseConstantSymbols[] = { + { + (const FcChar8 *) "antialias", + { + { FC_ANTIALIAS_OBJECT, 15, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "autohint", + { + { FC_AUTOHINT_OBJECT, 19, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "bgr", + { + { FC_RGBA_OBJECT, 27, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "black", + { + { FC_WEIGHT_OBJECT, 8, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "bold", + { + { FC_WEIGHT_OBJECT, 8, 1 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "book", + { + { FC_WEIGHT_OBJECT, 8, 2 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "charcell", + { + { FC_SPACING_OBJECT, 13, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "condensed", + { + { FC_WIDTH_OBJECT, 9, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "cursive", + { + { FC_GENERIC_FAMILY_OBJECT, 56, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "decorative", + { + { FC_DECORATIVE_OBJECT, 40, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "demibold", + { + { FC_WEIGHT_OBJECT, 8, 3 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "demilight", + { + { FC_WEIGHT_OBJECT, 8, 4 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "dual", + { + { FC_SPACING_OBJECT, 13, 1 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "embeddedbitmap", + { + { FC_EMBEDDED_BITMAP_OBJECT, 39, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "embolden", + { + { FC_EMBOLDEN_OBJECT, 38, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "emoji", + { + { FC_GENERIC_FAMILY_OBJECT, 56, 1 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "expanded", + { + { FC_WIDTH_OBJECT, 9, 1 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "extrablack", + { + { FC_WEIGHT_OBJECT, 8, 5 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "extrabold", + { + { FC_WEIGHT_OBJECT, 8, 6 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "extracondensed", + { + { FC_WIDTH_OBJECT, 9, 2 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "extraexpanded", + { + { FC_WIDTH_OBJECT, 9, 3 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "extralight", + { + { FC_WEIGHT_OBJECT, 8, 7 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "fangsong", + { + { FC_GENERIC_FAMILY_OBJECT, 56, 2 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "fantasy", + { + { FC_GENERIC_FAMILY_OBJECT, 56, 3 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "globaladvance", + { + { FC_GLOBAL_ADVANCE_OBJECT, 20, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "heavy", + { + { FC_WEIGHT_OBJECT, 8, 8 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "hintfull", + { + { FC_HINT_STYLE_OBJECT, 16, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "hinting", + { + { FC_HINTING_OBJECT, 17, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "hintmedium", + { + { FC_HINT_STYLE_OBJECT, 16, 1 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "hintnone", + { + { FC_HINT_STYLE_OBJECT, 16, 2 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "hintslight", + { + { FC_HINT_STYLE_OBJECT, 16, 3 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "italic", + { + { FC_SLANT_OBJECT, 7, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "lcddefault", + { + { FC_LCD_FILTER_OBJECT, 41, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "lcdlegacy", + { + { FC_LCD_FILTER_OBJECT, 41, 1 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "lcdlight", + { + { FC_LCD_FILTER_OBJECT, 41, 2 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "lcdnone", + { + { FC_LCD_FILTER_OBJECT, 41, 3 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "light", + { + { FC_WEIGHT_OBJECT, 8, 9 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "math", + { + { FC_GENERIC_FAMILY_OBJECT, 56, 4 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "medium", + { + { FC_WEIGHT_OBJECT, 8, 10 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "minspace", + { + { FC_MINSPACE_OBJECT, 29, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "mono", + { + { FC_SPACING_OBJECT, 13, 2 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "monospace", + { + { FC_GENERIC_FAMILY_OBJECT, 56, 5 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "none", + { + { FC_RGBA_OBJECT, 27, 1 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "normal", + { + { FC_WEIGHT_OBJECT, 8, 11 }, + { FC_WIDTH_OBJECT, 9, 4 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "oblique", + { + { FC_SLANT_OBJECT, 7, 1 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "outline", + { + { FC_OUTLINE_OBJECT, 24, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "proportional", + { + { FC_SPACING_OBJECT, 13, 3 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "regular", + { + { FC_WEIGHT_OBJECT, 8, 12 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "rgb", + { + { FC_RGBA_OBJECT, 27, 2 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "roman", + { + { FC_SLANT_OBJECT, 7, 2 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "sans-serif", + { + { FC_GENERIC_FAMILY_OBJECT, 56, 6 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "scalable", + { + { FC_SCALABLE_OBJECT, 25, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "semibold", + { + { FC_WEIGHT_OBJECT, 8, 13 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "semicondensed", + { + { FC_WIDTH_OBJECT, 9, 5 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "semiexpanded", + { + { FC_WIDTH_OBJECT, 9, 6 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "semilight", + { + { FC_WEIGHT_OBJECT, 8, 14 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "serif", + { + { FC_GENERIC_FAMILY_OBJECT, 56, 7 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "system-ui", + { + { FC_GENERIC_FAMILY_OBJECT, 56, 8 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "thin", + { + { FC_WEIGHT_OBJECT, 8, 15 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "ui-monospace", + { + { FC_GENERIC_FAMILY_OBJECT, 56, 9 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "ui-rounded", + { + { FC_GENERIC_FAMILY_OBJECT, 56, 10 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "ui-sans-serif", + { + { FC_GENERIC_FAMILY_OBJECT, 56, 11 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "ui-serif", + { + { FC_GENERIC_FAMILY_OBJECT, 56, 12 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "ultrablack", + { + { FC_WEIGHT_OBJECT, 8, 16 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "ultrabold", + { + { FC_WEIGHT_OBJECT, 8, 17 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "ultracondensed", + { + { FC_WIDTH_OBJECT, 9, 7 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "ultraexpanded", + { + { FC_WIDTH_OBJECT, 9, 8 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "ultralight", + { + { FC_WEIGHT_OBJECT, 8, 18 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "unknown", + { + { FC_RGBA_OBJECT, 27, 3 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "vbgr", + { + { FC_RGBA_OBJECT, 27, 4 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "verticallayout", + { + { FC_VERTICAL_LAYOUT_OBJECT, 18, 0 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, + { + (const FcChar8 *) "vrgb", + { + { FC_RGBA_OBJECT, 27, 5 }, + { FC_INVALID_OBJECT, 0, 0 }, + }, + }, +}; + +#define NUM_FC_CONST_SYMBOLS (sizeof (_FcBaseConstantSymbols) / sizeof (_FcBaseConstantSymbols[0])) + +typedef struct _fcConstObjects { + FcConstant values[20]; +} FcConstantObjects; + +static const FcConstantObjects _FcBaseConstantObjects[FC_MAX_BASE_OBJECT+1] = { + {{{ NULL, NULL, 0 }}} /* FC_INVALID_OBJECT */, + {{{ NULL, NULL, 0 }}} /* FC_FAMILY */, + {{{ NULL, NULL, 0 }}} /* FC_FAMILYLANG */, + {{{ NULL, NULL, 0 }}} /* FC_STYLE */, + {{{ NULL, NULL, 0 }}} /* FC_STYLELANG */, + {{{ NULL, NULL, 0 }}} /* FC_FULLNAME */, + {{{ NULL, NULL, 0 }}} /* FC_FULLNAMELANG */, + {{ + { (const FcChar8 *) "italic", FC_SLANT, FC_SLANT_ITALIC}, + { (const FcChar8 *) "oblique", FC_SLANT, FC_SLANT_OBLIQUE}, + { (const FcChar8 *) "roman", FC_SLANT, FC_SLANT_ROMAN}, + { NULL, NULL, 0 }, + }}, + {{ + { (const FcChar8 *) "black", FC_WEIGHT, FC_WEIGHT_BLACK}, + { (const FcChar8 *) "bold", FC_WEIGHT, FC_WEIGHT_BOLD}, + { (const FcChar8 *) "book", FC_WEIGHT, FC_WEIGHT_BOOK}, + { (const FcChar8 *) "demibold", FC_WEIGHT, FC_WEIGHT_DEMIBOLD}, + { (const FcChar8 *) "demilight", FC_WEIGHT, FC_WEIGHT_DEMILIGHT}, + { (const FcChar8 *) "extrablack", FC_WEIGHT, FC_WEIGHT_EXTRABLACK}, + { (const FcChar8 *) "extrabold", FC_WEIGHT, FC_WEIGHT_EXTRABOLD}, + { (const FcChar8 *) "extralight", FC_WEIGHT, FC_WEIGHT_EXTRALIGHT}, + { (const FcChar8 *) "heavy", FC_WEIGHT, FC_WEIGHT_HEAVY}, + { (const FcChar8 *) "light", FC_WEIGHT, FC_WEIGHT_LIGHT}, + { (const FcChar8 *) "medium", FC_WEIGHT, FC_WEIGHT_MEDIUM}, + { (const FcChar8 *) "normal", FC_WEIGHT, FC_WEIGHT_NORMAL}, + { (const FcChar8 *) "regular", FC_WEIGHT, FC_WEIGHT_REGULAR}, + { (const FcChar8 *) "semibold", FC_WEIGHT, FC_WEIGHT_DEMIBOLD}, + { (const FcChar8 *) "semilight", FC_WEIGHT, FC_WEIGHT_DEMILIGHT}, + { (const FcChar8 *) "thin", FC_WEIGHT, FC_WEIGHT_THIN}, + { (const FcChar8 *) "ultrablack", FC_WEIGHT, FC_WEIGHT_ULTRABLACK}, + { (const FcChar8 *) "ultrabold", FC_WEIGHT, FC_WEIGHT_EXTRABOLD}, + { (const FcChar8 *) "ultralight", FC_WEIGHT, FC_WEIGHT_EXTRALIGHT}, + { NULL, NULL, 0 }, + }}, + {{ + { (const FcChar8 *) "condensed", FC_WIDTH, FC_WIDTH_CONDENSED}, + { (const FcChar8 *) "expanded", FC_WIDTH, FC_WIDTH_EXPANDED}, + { (const FcChar8 *) "extracondensed", FC_WIDTH, FC_WIDTH_EXTRACONDENSED}, + { (const FcChar8 *) "extraexpanded", FC_WIDTH, FC_WIDTH_EXTRAEXPANDED}, + { (const FcChar8 *) "normal", FC_WIDTH, FC_WIDTH_NORMAL}, + { (const FcChar8 *) "semicondensed", FC_WIDTH, FC_WIDTH_SEMICONDENSED}, + { (const FcChar8 *) "semiexpanded", FC_WIDTH, FC_WIDTH_SEMIEXPANDED}, + { (const FcChar8 *) "ultracondensed", FC_WIDTH, FC_WIDTH_ULTRACONDENSED}, + { (const FcChar8 *) "ultraexpanded", FC_WIDTH, FC_WIDTH_ULTRAEXPANDED}, + { NULL, NULL, 0 }, + }}, + {{{ NULL, NULL, 0 }}} /* FC_SIZE */, + {{{ NULL, NULL, 0 }}} /* FC_ASPECT */, + {{{ NULL, NULL, 0 }}} /* FC_PIXEL_SIZE */, + {{ + { (const FcChar8 *) "charcell", FC_SPACING, FC_SPACING_CHARCELL}, + { (const FcChar8 *) "dual", FC_SPACING, FC_SPACING_DUAL}, + { (const FcChar8 *) "mono", FC_SPACING, FC_SPACING_MONO}, + { (const FcChar8 *) "proportional", FC_SPACING, FC_SPACING_PROPORTIONAL}, + { NULL, NULL, 0 }, + }}, + {{{ NULL, NULL, 0 }}} /* FC_FOUNDRY */, + {{ + { (const FcChar8 *) "antialias", FC_ANTIALIAS, FcTrue}, + { NULL, NULL, 0 }, + }}, + {{ + { (const FcChar8 *) "hintfull", FC_HINT_STYLE, FC_HINT_FULL}, + { (const FcChar8 *) "hintmedium", FC_HINT_STYLE, FC_HINT_MEDIUM}, + { (const FcChar8 *) "hintnone", FC_HINT_STYLE, FC_HINT_NONE}, + { (const FcChar8 *) "hintslight", FC_HINT_STYLE, FC_HINT_SLIGHT}, + { NULL, NULL, 0 }, + }}, + {{ + { (const FcChar8 *) "hinting", FC_HINTING, FcTrue}, + { NULL, NULL, 0 }, + }}, + {{ + { (const FcChar8 *) "verticallayout", FC_VERTICAL_LAYOUT, FcTrue}, + { NULL, NULL, 0 }, + }}, + {{ + { (const FcChar8 *) "autohint", FC_AUTOHINT, FcTrue}, + { NULL, NULL, 0 }, + }}, + {{ + { (const FcChar8 *) "globaladvance", FC_GLOBAL_ADVANCE, FcTrue}, + { NULL, NULL, 0 }, + }}, + {{{ NULL, NULL, 0 }}} /* FC_FILE */, + {{{ NULL, NULL, 0 }}} /* FC_INDEX */, + {{{ NULL, NULL, 0 }}} /* FC_RASTERIZER */, + {{ + { (const FcChar8 *) "outline", FC_OUTLINE, FcTrue}, + { NULL, NULL, 0 }, + }}, + {{ + { (const FcChar8 *) "scalable", FC_SCALABLE, FcTrue}, + { NULL, NULL, 0 }, + }}, + {{{ NULL, NULL, 0 }}} /* FC_DPI */, + {{ + { (const FcChar8 *) "bgr", FC_RGBA, FC_RGBA_BGR}, + { (const FcChar8 *) "none", FC_RGBA, FC_RGBA_NONE}, + { (const FcChar8 *) "rgb", FC_RGBA, FC_RGBA_RGB}, + { (const FcChar8 *) "unknown", FC_RGBA, FC_RGBA_UNKNOWN}, + { (const FcChar8 *) "vbgr", FC_RGBA, FC_RGBA_VBGR}, + { (const FcChar8 *) "vrgb", FC_RGBA, FC_RGBA_VRGB}, + { NULL, NULL, 0 }, + }}, + {{{ NULL, NULL, 0 }}} /* FC_SCALE */, + {{ + { (const FcChar8 *) "minspace", FC_MINSPACE, FcTrue}, + { NULL, NULL, 0 }, + }}, + {{{ NULL, NULL, 0 }}} /* FC_CHARWIDTH */, + {{{ NULL, NULL, 0 }}} /* FC_CHAR_HEIGHT */, + {{{ NULL, NULL, 0 }}} /* FC_MATRIX */, + {{{ NULL, NULL, 0 }}} /* FC_CHARSET */, + {{{ NULL, NULL, 0 }}} /* FC_LANG */, + {{{ NULL, NULL, 0 }}} /* FC_FONTVERSION */, + {{{ NULL, NULL, 0 }}} /* FC_CAPABILITY */, + {{{ NULL, NULL, 0 }}} /* FC_FONTFORMAT */, + {{ + { (const FcChar8 *) "embolden", FC_EMBOLDEN, FcTrue}, + { NULL, NULL, 0 }, + }}, + {{ + { (const FcChar8 *) "embeddedbitmap", FC_EMBEDDED_BITMAP, FcTrue}, + { NULL, NULL, 0 }, + }}, + {{ + { (const FcChar8 *) "decorative", FC_DECORATIVE, FcTrue}, + { NULL, NULL, 0 }, + }}, + {{ + { (const FcChar8 *) "lcddefault", FC_LCD_FILTER, FC_LCD_DEFAULT}, + { (const FcChar8 *) "lcdlegacy", FC_LCD_FILTER, FC_LCD_LEGACY}, + { (const FcChar8 *) "lcdlight", FC_LCD_FILTER, FC_LCD_LIGHT}, + { (const FcChar8 *) "lcdnone", FC_LCD_FILTER, FC_LCD_NONE}, + { NULL, NULL, 0 }, + }}, + {{{ NULL, NULL, 0 }}} /* FC_NAMELANG */, + {{{ NULL, NULL, 0 }}} /* FC_FONT_FEATURES */, + {{{ NULL, NULL, 0 }}} /* FC_PRGNAME */, + {{{ NULL, NULL, 0 }}} /* FC_HASH */, + {{{ NULL, NULL, 0 }}} /* FC_POSTSCRIPT_NAME */, + {{{ NULL, NULL, 0 }}} /* FC_COLOR */, + {{{ NULL, NULL, 0 }}} /* FC_SYMBOL */, + {{{ NULL, NULL, 0 }}} /* FC_FONT_VARIATIONS */, + {{{ NULL, NULL, 0 }}} /* FC_VARIABLE */, + {{{ NULL, NULL, 0 }}} /* FC_FONT_HAS_HINT */, + {{{ NULL, NULL, 0 }}} /* FC_ORDER */, + {{{ NULL, NULL, 0 }}} /* FC_DESKTOP_NAME */, + {{{ NULL, NULL, 0 }}} /* FC_NAMED_INSTANCE */, + {{{ NULL, NULL, 0 }}} /* FC_FONT_WRAPPER */, + {{ + { (const FcChar8 *) "cursive", FC_GENERIC_FAMILY, FC_FAMILY_CURSIVE}, + { (const FcChar8 *) "emoji", FC_GENERIC_FAMILY, FC_FAMILY_EMOJI}, + { (const FcChar8 *) "fangsong", FC_GENERIC_FAMILY, FC_FAMILY_FANGSONG}, + { (const FcChar8 *) "fantasy", FC_GENERIC_FAMILY, FC_FAMILY_FANTASY}, + { (const FcChar8 *) "math", FC_GENERIC_FAMILY, FC_FAMILY_MATH}, + { (const FcChar8 *) "monospace", FC_GENERIC_FAMILY, FC_FAMILY_MONO}, + { (const FcChar8 *) "sans-serif", FC_GENERIC_FAMILY, FC_FAMILY_SANS}, + { (const FcChar8 *) "serif", FC_GENERIC_FAMILY, FC_FAMILY_SERIF}, + { (const FcChar8 *) "system-ui", FC_GENERIC_FAMILY, FC_FAMILY_SYSTEM_UI}, + { (const FcChar8 *) "ui-monospace", FC_GENERIC_FAMILY, FC_FAMILY_UI_MONO}, + { (const FcChar8 *) "ui-rounded", FC_GENERIC_FAMILY, FC_FAMILY_UI_ROUNDED}, + { (const FcChar8 *) "ui-sans-serif", FC_GENERIC_FAMILY, FC_FAMILY_UI_SANS}, + { (const FcChar8 *) "ui-serif", FC_GENERIC_FAMILY, FC_FAMILY_UI_SERIF}, + { NULL, NULL, 0 }, + }}, +}; + +#define NUM_FC_CONST_OBJS (sizeof (_FcBaseConstantObjects) / sizeof (_FcBaseConstantObjects[0])) diff --git a/pkg/fontconfig/override/fc-genericfamily/fcgenericfamily.h b/pkg/fontconfig/override/fc-genericfamily/fcgenericfamily.h new file mode 100644 index 000000000..ed25cd45a --- /dev/null +++ b/pkg/fontconfig/override/fc-genericfamily/fcgenericfamily.h @@ -0,0 +1,6963 @@ +/* ANSI-C code produced by gperf version 3.3 */ +/* Command-line: gperf --pic -m 100 fcgenericfamily.gperf */ +/* Computed positions: -k'1,3-5,8,10-18,20,$' */ + +#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \ + && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \ + && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \ + && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \ + && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \ + && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \ + && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \ + && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \ + && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \ + && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \ + && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \ + && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \ + && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \ + && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \ + && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \ + && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \ + && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \ + && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \ + && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \ + && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \ + && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \ + && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \ + && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126)) +/* The character set is not based on ISO-646. */ +#error "gperf generated tables don't work with this execution character set. Please report a bug to ." +#endif + +#line 5 "fcgenericfamily.gperf" + +#include +#include + +struct FcGenericFamilyEntry { + int name; + uint32_t classification; /* Bit field of FC_FAMILY_* values */ +}; +#line 26 "fcgenericfamily.gperf" +struct FcGenericFamilyEntry; +#include + +#define TOTAL_KEYWORDS 1219 +#define MIN_WORD_LENGTH 2 +#define MAX_WORD_LENGTH 34 +#define MIN_HASH_VALUE 93 +#define MAX_HASH_VALUE 12005 +/* maximum key range = 11913, duplicates = 0 */ + +#ifndef GPERF_DOWNCASE +#define GPERF_DOWNCASE 1 +static const unsigned char gperf_downcase[256] = + { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255 + }; +#endif + +#ifndef GPERF_CASE_STRCMP +#define GPERF_CASE_STRCMP 1 +static int +gperf_case_strcmp (register const char *s1, register const char *s2) +{ + for (;;) + { + unsigned char c1 = gperf_downcase[(unsigned char)*s1++]; + unsigned char c2 = gperf_downcase[(unsigned char)*s2++]; + if (c1 != 0 && c1 == c2) + continue; + return (int)c1 - (int)c2; + } +} +#endif + +#ifdef __GNUC__ +__inline +#else +#ifdef __cplusplus +inline +#endif +#endif +static unsigned int +fc_generic_family_hash (register const char *str, register size_t len) +{ + static const unsigned short asso_values[] = + { + 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, + 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, + 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, + 12006, 12006, 25, 12006, 12006, 12006, 12006, 12006, 12006, 12006, + 18, 18, 12006, 12006, 12006, 18, 12006, 18, 30, 19, + 32, 19, 23, 25, 12006, 22, 20, 19, 12006, 12006, + 12006, 12006, 12006, 12006, 12006, 20, 2827, 129, 264, 43, + 1384, 353, 788, 18, 1347, 733, 249, 26, 18, 23, + 2269, 22, 20, 31, 53, 776, 3005, 2024, 2042, 1815, + 200, 12006, 12006, 12006, 12006, 18, 12006, 20, 2827, 129, + 264, 43, 1384, 353, 788, 18, 1347, 733, 249, 26, + 18, 23, 2269, 22, 20, 31, 53, 776, 3005, 2024, + 2042, 1815, 200, 12006, 12006, 12006, 12006, 12006, 12006, 12006, + 18, 18, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, + 12006, 19, 19, 12006, 12006, 12006, 12006, 12006, 12006, 12006, + 12006, 12006, 12006, 12006, 12006, 12006, 19, 19, 12006, 12006, + 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 18, 12006, + 12006, 12006, 12006, 12006, 12006, 18, 12006, 12006, 12006, 12006, + 18, 12006, 12006, 18, 12006, 12006, 12006, 12006, 12006, 18, + 12006, 12006, 12006, 12006, 12006, 19, 12006, 12006, 12006, 12006, + 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, + 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, + 12006, 12006, 12006, 12006, 12006, 12006, 12006, 18, 12006, 12006, + 18, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 18, + 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, 12006, + 12006, 12006, 12006, 12006, 12006, 12006 + }; + register unsigned int hval = len; + + switch (hval) + { + default: + hval += asso_values[(unsigned char)str[19]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 19: + case 18: + hval += asso_values[(unsigned char)str[17]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 17: + hval += asso_values[(unsigned char)str[16]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 16: + hval += asso_values[(unsigned char)str[15]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 15: + hval += asso_values[(unsigned char)str[14]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 14: + hval += asso_values[(unsigned char)str[13]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 13: + hval += asso_values[(unsigned char)str[12]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 12: + hval += asso_values[(unsigned char)str[11]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 11: + hval += asso_values[(unsigned char)str[10]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 10: + hval += asso_values[(unsigned char)str[9]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 9: + case 8: + hval += asso_values[(unsigned char)str[7]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 7: + case 6: + case 5: + hval += asso_values[(unsigned char)str[4]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 4: + hval += asso_values[(unsigned char)str[3]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 3: + hval += asso_values[(unsigned char)str[2]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif + /*FALLTHROUGH*/ + case 2: + case 1: + hval += asso_values[(unsigned char)str[0]]; + break; + } + return hval + asso_values[(unsigned char)str[len - 1]]; +} + +struct FcConstFamilyNamePool_t + { + char FcConstFamilyNamePool_str93[sizeof("sina")]; + char FcConstFamilyNamePool_str95[sizeof("sora")]; + char FcConstFamilyNamePool_str99[sizeof("amiri")]; + char FcConstFamilyNamePool_str105[sizeof("raanana")]; + char FcConstFamilyNamePool_str107[sizeof("asea")]; + char FcConstFamilyNamePool_str108[sizeof("aroania")]; + char FcConstFamilyNamePool_str113[sizeof("norasi")]; + char FcConstFamilyNamePool_str115[sizeof("arimo")]; + char FcConstFamilyNamePool_str118[sizeof("nsimsun")]; + char FcConstFamilyNamePool_str120[sizeof("m+ 1mn")]; + char FcConstFamilyNamePool_str124[sizeof("nasim")]; + char FcConstFamilyNamePool_str125[sizeof("avenir")]; + char FcConstFamilyNamePool_str127[sizeof("m+ 1m")]; + char FcConstFamilyNamePool_str129[sizeof("mononoki")]; + char FcConstFamilyNamePool_str134[sizeof("meera")]; + char FcConstFamilyNamePool_str135[sizeof("sf mono")]; + char FcConstFamilyNamePool_str136[sizeof("nunito")]; + char FcConstFamilyNamePool_str137[sizeof("manrope")]; + char FcConstFamilyNamePool_str140[sizeof("m+ 2m")]; + char FcConstFamilyNamePool_str144[sizeof("mitra")]; + char FcConstFamilyNamePool_str146[sizeof("optima")]; + char FcConstFamilyNamePool_str150[sizeof("titr")]; + char FcConstFamilyNamePool_str154[sizeof("anorexia")]; + char FcConstFamilyNamePool_str155[sizeof("nirmala ui")]; + char FcConstFamilyNamePool_str156[sizeof("ibm 3270")]; + char FcConstFamilyNamePool_str159[sizeof("inter")]; + char FcConstFamilyNamePool_str160[sizeof("exo 2")]; + char FcConstFamilyNamePool_str161[sizeof("tinos")]; + char FcConstFamilyNamePool_str165[sizeof("shimenkan")]; + char FcConstFamilyNamePool_str167[sizeof("open sans")]; + char FcConstFamilyNamePool_str172[sizeof("mint mono")]; + char FcConstFamilyNamePool_str177[sizeof("noto sans")]; + char FcConstFamilyNamePool_str185[sizeof("miriam mono")]; + char FcConstFamilyNamePool_str187[sizeof("terminus")]; + char FcConstFamilyNamePool_str188[sizeof("noto emoji")]; + char FcConstFamilyNamePool_str189[sizeof("times")]; + char FcConstFamilyNamePool_str194[sizeof("smoothansi")]; + char FcConstFamilyNamePool_str196[sizeof("c059")]; + char FcConstFamilyNamePool_str198[sizeof("\357\275\215\357\275\223 \346\230\216\346\234\235")]; + char FcConstFamilyNamePool_str208[sizeof("mrs eaves")]; + char FcConstFamilyNamePool_str215[sizeof("museo sans")]; + char FcConstFamilyNamePool_str218[sizeof("cairo")]; + char FcConstFamilyNamePool_str222[sizeof("monaco")]; + char FcConstFamilyNamePool_str229[sizeof("nunito sans")]; + char FcConstFamilyNamePool_str230[sizeof("musica")]; + char FcConstFamilyNamePool_str233[sizeof("clean")]; + char FcConstFamilyNamePool_str239[sizeof("cure")]; + char FcConstFamilyNamePool_str243[sizeof("zar")]; + char FcConstFamilyNamePool_str246[sizeof("mint mono 35")]; + char FcConstFamilyNamePool_str249[sizeof("charter")]; + char FcConstFamilyNamePool_str251[sizeof("console")]; + char FcConstFamilyNamePool_str252[sizeof("operator mono")]; + char FcConstFamilyNamePool_str262[sizeof("clarendon")]; + char FcConstFamilyNamePool_str264[sizeof("montserrat")]; + char FcConstFamilyNamePool_str267[sizeof("noto sans mro")]; + char FcConstFamilyNamePool_str271[sizeof("consolas")]; + char FcConstFamilyNamePool_str272[sizeof("z003")]; + char FcConstFamilyNamePool_str273[sizeof("spacemono")]; + char FcConstFamilyNamePool_str274[sizeof("aharoniclm")]; + char FcConstFamilyNamePool_str275[sizeof("miriam clm")]; + char FcConstFamilyNamePool_str278[sizeof("cormorant")]; + char FcConstFamilyNamePool_str286[sizeof("noto sans miao")]; + char FcConstFamilyNamePool_str289[sizeof("noto sans mono")]; + char FcConstFamilyNamePool_str290[sizeof("\357\275\215\357\275\223 \343\202\264\343\202\267\343\203\203\343\202\257")]; + char FcConstFamilyNamePool_str297[sizeof("tiza")]; + char FcConstFamilyNamePool_str302[sizeof("space mono")]; + char FcConstFamilyNamePool_str304[sizeof("clear sans")]; + char FcConstFamilyNamePool_str306[sizeof("crimson pro")]; + char FcConstFamilyNamePool_str308[sizeof("eczar")]; + char FcConstFamilyNamePool_str313[sizeof("lora")]; + char FcConstFamilyNamePool_str315[sizeof("muli")]; + char FcConstFamilyNamePool_str319[sizeof("loma")]; + char FcConstFamilyNamePool_str330[sizeof("commissioner")]; + char FcConstFamilyNamePool_str331[sizeof("dror")]; + char FcConstFamilyNamePool_str334[sizeof("constantia")]; + char FcConstFamilyNamePool_str344[sizeof("menlo")]; + char FcConstFamilyNamePool_str348[sizeof("avdira")]; + char FcConstFamilyNamePool_str351[sizeof("madan")]; + char FcConstFamilyNamePool_str352[sizeof("lato")]; + char FcConstFamilyNamePool_str355[sizeof("monoid")]; + char FcConstFamilyNamePool_str357[sizeof("meslo")]; + char FcConstFamilyNamePool_str361[sizeof("times new roman")]; + char FcConstFamilyNamePool_str364[sizeof("monolisa")]; + char FcConstFamilyNamePool_str365[sizeof("lime")]; + char FcConstFamilyNamePool_str366[sizeof("madan2")]; + char FcConstFamilyNamePool_str369[sizeof("sharetechmono")]; + char FcConstFamilyNamePool_str377[sizeof("mnmlicons")]; + char FcConstFamilyNamePool_str378[sizeof("dm sans")]; + char FcConstFamilyNamePool_str380[sizeof("analecta")]; + char FcConstFamilyNamePool_str381[sizeof("noto sans armenian")]; + char FcConstFamilyNamePool_str382[sizeof("zysong18030")]; + char FcConstFamilyNamePool_str385[sizeof("lotoos")]; + char FcConstFamilyNamePool_str386[sizeof("smonohand")]; + char FcConstFamilyNamePool_str391[sizeof("itc stone sans")]; + char FcConstFamilyNamePool_str406[sizeof("notcouriersans")]; + char FcConstFamilyNamePool_str407[sizeof("noto sans samaritan")]; + char FcConstFamilyNamePool_str409[sizeof("molot")]; + char FcConstFamilyNamePool_str413[sizeof("literata")]; + char FcConstFamilyNamePool_str414[sizeof("noto sans masaram gondi")]; + char FcConstFamilyNamePool_str415[sizeof("thorndale")]; + char FcConstFamilyNamePool_str418[sizeof("noto music")]; + char FcConstFamilyNamePool_str420[sizeof("dustismo")]; + char FcConstFamilyNamePool_str421[sizeof("noto sans carian")]; + char FcConstFamilyNamePool_str427[sizeof("epilogue")]; + char FcConstFamilyNamePool_str439[sizeof("din next")]; + char FcConstFamilyNamePool_str441[sizeof("comic neue")]; + char FcConstFamilyNamePool_str446[sizeof("carlito")]; + char FcConstFamilyNamePool_str450[sizeof("irannastaliq")]; + char FcConstFamilyNamePool_str455[sizeof("cascadia mono")]; + char FcConstFamilyNamePool_str456[sizeof("caslon")]; + char FcConstFamilyNamePool_str457[sizeof("go mono")]; + char FcConstFamilyNamePool_str458[sizeof("candara")]; + char FcConstFamilyNamePool_str460[sizeof("aegean")]; + char FcConstFamilyNamePool_str462[sizeof("stsong")]; + char FcConstFamilyNamePool_str464[sizeof("cardo")]; + char FcConstFamilyNamePool_str469[sizeof("tunga")]; + char FcConstFamilyNamePool_str471[sizeof("simsong")]; + char FcConstFamilyNamePool_str479[sizeof("comic sans ms")]; + char FcConstFamilyNamePool_str480[sizeof("gfs olga")]; + char FcConstFamilyNamePool_str484[sizeof("alegreya")]; + char FcConstFamilyNamePool_str490[sizeof("noto sans lao")]; + char FcConstFamilyNamePool_str494[sizeof("segoe ui")]; + char FcConstFamilyNamePool_str499[sizeof("comicshannsmono")]; + char FcConstFamilyNamePool_str502[sizeof("awami nastaliq")]; + char FcConstFamilyNamePool_str506[sizeof("edges")]; + char FcConstFamilyNamePool_str508[sizeof("nazli")]; + char FcConstFamilyNamePool_str513[sizeof("geist")]; + char FcConstFamilyNamePool_str514[sizeof("code2001")]; + char FcConstFamilyNamePool_str519[sizeof("elliniaclm")]; + char FcConstFamilyNamePool_str522[sizeof("gfs ignacio")]; + char FcConstFamilyNamePool_str525[sizeof("noto sans modi")]; + char FcConstFamilyNamePool_str533[sizeof("intel one mono")]; + char FcConstFamilyNamePool_str534[sizeof("geist mono")]; + char FcConstFamilyNamePool_str536[sizeof("code2000")]; + char FcConstFamilyNamePool_str541[sizeof("inconsolata")]; + char FcConstFamilyNamePool_str550[sizeof("gfs ambrosia")]; + char FcConstFamilyNamePool_str553[sizeof("thorndale amt")]; + char FcConstFamilyNamePool_str555[sizeof("laconic")]; + char FcConstFamilyNamePool_str559[sizeof("gfs solomos")]; + char FcConstFamilyNamePool_str561[sizeof("arial")]; + char FcConstFamilyNamePool_str568[sizeof("codenewroman")]; + char FcConstFamilyNamePool_str570[sizeof("ipagothic")]; + char FcConstFamilyNamePool_str583[sizeof("ms gothic")]; + char FcConstFamilyNamePool_str587[sizeof("d-din")]; + char FcConstFamilyNamePool_str592[sizeof("gfs artemisia")]; + char FcConstFamilyNamePool_str600[sizeof("alegreya sans")]; + char FcConstFamilyNamePool_str603[sizeof("great vibes")]; + char FcConstFamilyNamePool_str606[sizeof("openmoji color")]; + char FcConstFamilyNamePool_str610[sizeof("latin modern roman")]; + char FcConstFamilyNamePool_str611[sizeof("gfs nicefore")]; + char FcConstFamilyNamePool_str613[sizeof("noto sans linear a")]; + char FcConstFamilyNamePool_str614[sizeof("ezra sil")]; + char FcConstFamilyNamePool_str621[sizeof("miriam mono clm")]; + char FcConstFamilyNamePool_str623[sizeof("terminal")]; + char FcConstFamilyNamePool_str624[sizeof("songti sc")]; + char FcConstFamilyNamePool_str629[sizeof("noto sans tai le")]; + char FcConstFamilyNamePool_str639[sizeof("noto sans meroitic")]; + char FcConstFamilyNamePool_str646[sizeof("songti tc")]; + char FcConstFamilyNamePool_str654[sizeof("andale mono")]; + char FcConstFamilyNamePool_str655[sizeof("material icons")]; + char FcConstFamilyNamePool_str657[sizeof("mingzat")]; + char FcConstFamilyNamePool_str661[sizeof("droid sans")]; + char FcConstFamilyNamePool_str662[sizeof("didot")]; + char FcConstFamilyNamePool_str668[sizeof("geeza pro")]; + char FcConstFamilyNamePool_str672[sizeof("mangal")]; + char FcConstFamilyNamePool_str675[sizeof("gfs theokritos")]; + char FcConstFamilyNamePool_str677[sizeof("gulim")]; + char FcConstFamilyNamePool_str684[sizeof("mints mild")]; + char FcConstFamilyNamePool_str689[sizeof("caladea")]; + char FcConstFamilyNamePool_str690[sizeof("noto sans osage")]; + char FcConstFamilyNamePool_str693[sizeof("noto sans tangsa")]; + char FcConstFamilyNamePool_str711[sizeof("sniglet")]; + char FcConstFamilyNamePool_str716[sizeof("domestic manners")]; + char FcConstFamilyNamePool_str726[sizeof("charis sil")]; + char FcConstFamilyNamePool_str727[sizeof("cantarell")]; + char FcConstFamilyNamePool_str729[sizeof("noto sans deseret")]; + char FcConstFamilyNamePool_str731[sizeof("gfs eustace")]; + char FcConstFamilyNamePool_str744[sizeof("montserrat alternates")]; + char FcConstFamilyNamePool_str757[sizeof("latin modern roman caps")]; + char FcConstFamilyNamePool_str758[sizeof("gfs didot")]; + char FcConstFamilyNamePool_str762[sizeof("spectral")]; + char FcConstFamilyNamePool_str763[sizeof("noto sans indic siyaq numbers")]; + char FcConstFamilyNamePool_str767[sizeof("gargi")]; + char FcConstFamilyNamePool_str768[sizeof("lalezar")]; + char FcConstFamilyNamePool_str773[sizeof("droid sans mono")]; + char FcConstFamilyNamePool_str776[sizeof("georgia")]; + char FcConstFamilyNamePool_str779[sizeof("noto sans sora sompeng")]; + char FcConstFamilyNamePool_str782[sizeof("noto sans adlam")]; + char FcConstFamilyNamePool_str792[sizeof("noto sans tamil")]; + char FcConstFamilyNamePool_str796[sizeof("nu")]; + char FcConstFamilyNamePool_str803[sizeof("noto sans mandaic")]; + char FcConstFamilyNamePool_str806[sizeof("leland")]; + char FcConstFamilyNamePool_str807[sizeof("gentium basic")]; + char FcConstFamilyNamePool_str814[sizeof("kinnari")]; + char FcConstFamilyNamePool_str820[sizeof("gfs gazis")]; + char FcConstFamilyNamePool_str823[sizeof("kamran")]; + char FcConstFamilyNamePool_str827[sizeof("stkaiti")]; + char FcConstFamilyNamePool_str836[sizeof("aqui")]; + char FcConstFamilyNamePool_str840[sizeof("arial unicode")]; + char FcConstFamilyNamePool_str844[sizeof("cascadia code")]; + char FcConstFamilyNamePool_str845[sizeof("kaiti")]; + char FcConstFamilyNamePool_str847[sizeof("droid sans armenian")]; + char FcConstFamilyNamePool_str848[sizeof("crete round")]; + char FcConstFamilyNamePool_str851[sizeof("kartika")]; + char FcConstFamilyNamePool_str853[sizeof("mukti")]; + char FcConstFamilyNamePool_str858[sizeof("homa")]; + char FcConstFamilyNamePool_str866[sizeof("khmer ui")]; + char FcConstFamilyNamePool_str873[sizeof("anaktoria")]; + char FcConstFamilyNamePool_str876[sizeof("gfs galatea")]; + char FcConstFamilyNamePool_str877[sizeof("hanamin")]; + char FcConstFamilyNamePool_str879[sizeof("latin modern roman demi")]; + char FcConstFamilyNamePool_str883[sizeof("arshia")]; + char FcConstFamilyNamePool_str888[sizeof("simsun")]; + char FcConstFamilyNamePool_str889[sizeof("comicshannsmono nerd font")]; + char FcConstFamilyNamePool_str892[sizeof("khmer os")]; + char FcConstFamilyNamePool_str895[sizeof("latin modern roman slanted")]; + char FcConstFamilyNamePool_str896[sizeof("kates")]; + char FcConstFamilyNamePool_str901[sizeof("harmattan")]; + char FcConstFamilyNamePool_str902[sizeof("ipamincho")]; + char FcConstFamilyNamePool_str904[sizeof("shruti")]; + char FcConstFamilyNamePool_str905[sizeof("stheiti")]; + char FcConstFamilyNamePool_str907[sizeof("noto sans old north arabian")]; + char FcConstFamilyNamePool_str908[sizeof("elham")]; + char FcConstFamilyNamePool_str911[sizeof("hermit")]; + char FcConstFamilyNamePool_str912[sizeof("simhei")]; + char FcConstFamilyNamePool_str913[sizeof("arial unicode ms")]; + char FcConstFamilyNamePool_str915[sizeof("ms mincho")]; + char FcConstFamilyNamePool_str916[sizeof("tahoma")]; + char FcConstFamilyNamePool_str917[sizeof("mukta vaani")]; + char FcConstFamilyNamePool_str919[sizeof("amiri quran")]; + char FcConstFamilyNamePool_str921[sizeof("leelawadee")]; + char FcConstFamilyNamePool_str922[sizeof("inconsolatago")]; + char FcConstFamilyNamePool_str923[sizeof("mukta malar")]; + char FcConstFamilyNamePool_str924[sizeof("noto sans sogdian")]; + char FcConstFamilyNamePool_str929[sizeof("noto sans mongolian")]; + char FcConstFamilyNamePool_str934[sizeof("gill sans")]; + char FcConstFamilyNamePool_str940[sizeof("mints strong")]; + char FcConstFamilyNamePool_str948[sizeof("inconsolata go")]; + char FcConstFamilyNamePool_str950[sizeof("noto sans nandinagari")]; + char FcConstFamilyNamePool_str955[sizeof("garamond")]; + char FcConstFamilyNamePool_str967[sizeof("noto sans canadian aboriginal")]; + char FcConstFamilyNamePool_str970[sizeof("courier")]; + char FcConstFamilyNamePool_str972[sizeof("noto sans nko")]; + char FcConstFamilyNamePool_str975[sizeof("rit rachana")]; + char FcConstFamilyNamePool_str984[sizeof("rachana")]; + char FcConstFamilyNamePool_str985[sizeof("archivo")]; + char FcConstFamilyNamePool_str986[sizeof("noto sans ui")]; + char FcConstFamilyNamePool_str987[sizeof("merriweather")]; + char FcConstFamilyNamePool_str990[sizeof("kacstpen")]; + char FcConstFamilyNamePool_str992[sizeof("mukta mahee")]; + char FcConstFamilyNamePool_str993[sizeof("kacstqurn")]; + char FcConstFamilyNamePool_str994[sizeof("kacst-qr")]; + char FcConstFamilyNamePool_str995[sizeof("kacstqura")]; + char FcConstFamilyNamePool_str1004[sizeof("cousine")]; + char FcConstFamilyNamePool_str1006[sizeof("codenewroman nerd font mono")]; + char FcConstFamilyNamePool_str1012[sizeof("kacstfarsi")]; + char FcConstFamilyNamePool_str1024[sizeof("eb garamond")]; + char FcConstFamilyNamePool_str1031[sizeof("codenewroman nerd font")]; + char FcConstFamilyNamePool_str1039[sizeof("noto sans takri")]; + char FcConstFamilyNamePool_str1040[sizeof("kacstone")]; + char FcConstFamilyNamePool_str1045[sizeof("kalinga")]; + char FcConstFamilyNamePool_str1046[sizeof("noto sans georgian")]; + char FcConstFamilyNamePool_str1047[sizeof("karla")]; + char FcConstFamilyNamePool_str1051[sizeof("manchu2005")]; + char FcConstFamilyNamePool_str1055[sizeof("ume mincho")]; + char FcConstFamilyNamePool_str1056[sizeof("kacstscreen")]; + char FcConstFamilyNamePool_str1060[sizeof("kacstart")]; + char FcConstFamilyNamePool_str1061[sizeof("andika")]; + char FcConstFamilyNamePool_str1066[sizeof("alkalami")]; + char FcConstFamilyNamePool_str1071[sizeof("kacstposter")]; + char FcConstFamilyNamePool_str1073[sizeof("noto sans thai")]; + char FcConstFamilyNamePool_str1075[sizeof("untaza")]; + char FcConstFamilyNamePool_str1081[sizeof("akkadian")]; + char FcConstFamilyNamePool_str1082[sizeof("lekton")]; + char FcConstFamilyNamePool_str1086[sizeof("tscu_paranar")]; + char FcConstFamilyNamePool_str1090[sizeof("dank mono")]; + char FcConstFamilyNamePool_str1093[sizeof("kacstletter")]; + char FcConstFamilyNamePool_str1095[sizeof("kacsttitle")]; + char FcConstFamilyNamePool_str1097[sizeof("lao ui")]; + char FcConstFamilyNamePool_str1098[sizeof("share tech mono")]; + char FcConstFamilyNamePool_str1105[sizeof("anka/coder")]; + char FcConstFamilyNamePool_str1107[sizeof("ipamonamincho")]; + char FcConstFamilyNamePool_str1112[sizeof("source sans 3")]; + char FcConstFamilyNamePool_str1113[sizeof("latin modern roman dunhill")]; + char FcConstFamilyNamePool_str1115[sizeof("noto sans hatran")]; + char FcConstFamilyNamePool_str1117[sizeof("noto sans thaana")]; + char FcConstFamilyNamePool_str1118[sizeof("mplus")]; + char FcConstFamilyNamePool_str1124[sizeof("nuosu sil")]; + char FcConstFamilyNamePool_str1127[sizeof("hasida")]; + char FcConstFamilyNamePool_str1128[sizeof("merriweather sans")]; + char FcConstFamilyNamePool_str1129[sizeof("ume mincho s3")]; + char FcConstFamilyNamePool_str1133[sizeof("silkscreen")]; + char FcConstFamilyNamePool_str1149[sizeof("undotum")]; + char FcConstFamilyNamePool_str1150[sizeof("dotum")]; + char FcConstFamilyNamePool_str1160[sizeof("noto sans armenian ui")]; + char FcConstFamilyNamePool_str1165[sizeof("noto sans cham")]; + char FcConstFamilyNamePool_str1178[sizeof("nanumgothic")]; + char FcConstFamilyNamePool_str1184[sizeof("titillium")]; + char FcConstFamilyNamePool_str1193[sizeof("quicksand")]; + char FcConstFamilyNamePool_str1209[sizeof("noto sans tai tham")]; + char FcConstFamilyNamePool_str1210[sizeof("lucida console")]; + char FcConstFamilyNamePool_str1221[sizeof("red hat mono")]; + char FcConstFamilyNamePool_str1223[sizeof("raghindi")]; + char FcConstFamilyNamePool_str1227[sizeof("gautami")]; + char FcConstFamilyNamePool_str1230[sizeof("grand hotel")]; + char FcConstFamilyNamePool_str1241[sizeof("noto sans marchen")]; + char FcConstFamilyNamePool_str1242[sizeof("arundina sans")]; + char FcConstFamilyNamePool_str1246[sizeof("gotham")]; + char FcConstFamilyNamePool_str1259[sizeof("khmer os content")]; + char FcConstFamilyNamePool_str1267[sizeof("noto sans runic")]; + char FcConstFamilyNamePool_str1273[sizeof("noto sans chorasmian")]; + char FcConstFamilyNamePool_str1276[sizeof("droid sans tamil")]; + char FcConstFamilyNamePool_str1280[sizeof("noto sans manichaean")]; + char FcConstFamilyNamePool_str1292[sizeof("noto sans kannada")]; + char FcConstFamilyNamePool_str1307[sizeof("noto sans lao ui")]; + char FcConstFamilyNamePool_str1316[sizeof("aurulentsansmono")]; + char FcConstFamilyNamePool_str1320[sizeof("uniol")]; + char FcConstFamilyNamePool_str1325[sizeof("ungraphic")]; + char FcConstFamilyNamePool_str1327[sizeof("sazanami mincho")]; + char FcConstFamilyNamePool_str1336[sizeof("noto sans kannada ui")]; + char FcConstFamilyNamePool_str1341[sizeof("noto sans old italic")]; + char FcConstFamilyNamePool_str1343[sizeof("noto sans sinhala")]; + char FcConstFamilyNamePool_str1348[sizeof("hiragino sans")]; + char FcConstFamilyNamePool_str1354[sizeof("arundina sans mono")]; + char FcConstFamilyNamePool_str1357[sizeof("noto sans multani")]; + char FcConstFamilyNamePool_str1359[sizeof("lohit assamese")]; + char FcConstFamilyNamePool_str1362[sizeof("noto sans sharada")]; + char FcConstFamilyNamePool_str1376[sizeof("noto sans caucasian albanian")]; + char FcConstFamilyNamePool_str1378[sizeof("mukta devanagari")]; + char FcConstFamilyNamePool_str1383[sizeof("noto sans tamil ui")]; + char FcConstFamilyNamePool_str1384[sizeof("inconsolatalgc")]; + char FcConstFamilyNamePool_str1387[sizeof("noto sans sinhala ui")]; + char FcConstFamilyNamePool_str1393[sizeof("noto sans mende kikakui")]; + char FcConstFamilyNamePool_str1410[sizeof("noto traditional nushu")]; + char FcConstFamilyNamePool_str1411[sizeof("jura")]; + char FcConstFamilyNamePool_str1413[sizeof("noto sans ogham")]; + char FcConstFamilyNamePool_str1419[sizeof("aurulentsansmono nerd font")]; + char FcConstFamilyNamePool_str1422[sizeof("lohit odia")]; + char FcConstFamilyNamePool_str1425[sizeof("noto sans sundanese")]; + char FcConstFamilyNamePool_str1429[sizeof("mingliu")]; + char FcConstFamilyNamePool_str1437[sizeof("lohit hindi")]; + char FcConstFamilyNamePool_str1439[sizeof("garuda")]; + char FcConstFamilyNamePool_str1440[sizeof("hadasim clm")]; + char FcConstFamilyNamePool_str1449[sizeof("inconsolatalgc nerd font")]; + char FcConstFamilyNamePool_str1453[sizeof("noto sans old sogdian")]; + char FcConstFamilyNamePool_str1456[sizeof("gfs decker")]; + char FcConstFamilyNamePool_str1457[sizeof("caladingsclm")]; + char FcConstFamilyNamePool_str1460[sizeof("nachlieli")]; + char FcConstFamilyNamePool_str1468[sizeof("lohit nepali")]; + char FcConstFamilyNamePool_str1471[sizeof("noto sans grantha")]; + char FcConstFamilyNamePool_str1474[sizeof("gfs didot classic")]; + char FcConstFamilyNamePool_str1478[sizeof("monofur")]; + char FcConstFamilyNamePool_str1479[sizeof("trade gothic")]; + char FcConstFamilyNamePool_str1483[sizeof("lohit kannada")]; + char FcConstFamilyNamePool_str1484[sizeof("shofar")]; + char FcConstFamilyNamePool_str1499[sizeof("fira mono")]; + char FcConstFamilyNamePool_str1501[sizeof("emoji one")]; + char FcConstFamilyNamePool_str1505[sizeof("ff meta")]; + char FcConstFamilyNamePool_str1507[sizeof("fira sans")]; + char FcConstFamilyNamePool_str1508[sizeof("\303\251colier court")]; + char FcConstFamilyNamePool_str1512[sizeof("droid sans georgian")]; + char FcConstFamilyNamePool_str1523[sizeof("fantezi")]; + char FcConstFamilyNamePool_str1525[sizeof("reem kufi")]; + char FcConstFamilyNamePool_str1529[sizeof("d-din condensed")]; + char FcConstFamilyNamePool_str1537[sizeof("outfit")]; + char FcConstFamilyNamePool_str1541[sizeof("kerkis")]; + char FcConstFamilyNamePool_str1550[sizeof("freemono")]; + char FcConstFamilyNamePool_str1551[sizeof("kacsttitlel")]; + char FcConstFamilyNamePool_str1555[sizeof("hiragino sans cns")]; + char FcConstFamilyNamePool_str1557[sizeof("droid sans thai")]; + char FcConstFamilyNamePool_str1560[sizeof("courier std")]; + char FcConstFamilyNamePool_str1563[sizeof("keter yg")]; + char FcConstFamilyNamePool_str1566[sizeof("gentium plus")]; + char FcConstFamilyNamePool_str1570[sizeof("ipamonagothic")]; + char FcConstFamilyNamePool_str1571[sizeof("freesans")]; + char FcConstFamilyNamePool_str1601[sizeof("artsounk")]; + char FcConstFamilyNamePool_str1603[sizeof("noto sans tagalog")]; + char FcConstFamilyNamePool_str1611[sizeof("comfortaa")]; + char FcConstFamilyNamePool_str1616[sizeof("noto sans siddham")]; + char FcConstFamilyNamePool_str1617[sizeof("ff scala")]; + char FcConstFamilyNamePool_str1621[sizeof("noto looped lao ui")]; + char FcConstFamilyNamePool_str1629[sizeof("fontawesome")]; + char FcConstFamilyNamePool_str1642[sizeof("latin modern roman unslanted")]; + char FcConstFamilyNamePool_str1643[sizeof("stam ashkenaz clm")]; + char FcConstFamilyNamePool_str1648[sizeof("farnaz")]; + char FcConstFamilyNamePool_str1654[sizeof("lohit devanagari")]; + char FcConstFamilyNamePool_str1655[sizeof("lohit tamil")]; + char FcConstFamilyNamePool_str1670[sizeof("heuristica")]; + char FcConstFamilyNamePool_str1671[sizeof("noto sans gothic")]; + char FcConstFamilyNamePool_str1672[sizeof("gfs g\303\266schen")]; + char FcConstFamilyNamePool_str1676[sizeof("noto sans old south arabian")]; + char FcConstFamilyNamePool_str1680[sizeof("darkgarden")]; + char FcConstFamilyNamePool_str1684[sizeof("asana math")]; + char FcConstFamilyNamePool_str1685[sizeof("amiri quran colored")]; + char FcConstFamilyNamePool_str1686[sizeof("3270 nerd font")]; + char FcConstFamilyNamePool_str1689[sizeof("noto sans thai looped")]; + char FcConstFamilyNamePool_str1692[sizeof("jomolhari")]; + char FcConstFamilyNamePool_str1694[sizeof("segoe ui historic")]; + char FcConstFamilyNamePool_str1696[sizeof("noto sans ugaritic")]; + char FcConstFamilyNamePool_str1706[sizeof("terminus (ttf)")]; + char FcConstFamilyNamePool_str1711[sizeof("kacstbook")]; + char FcConstFamilyNamePool_str1713[sizeof("san francisco")]; + char FcConstFamilyNamePool_str1715[sizeof("ff din")]; + char FcConstFamilyNamePool_str1716[sizeof("ferdosi")]; + char FcConstFamilyNamePool_str1718[sizeof("leelawadee ui")]; + char FcConstFamilyNamePool_str1719[sizeof("noto fangsong kss rotated")]; + char FcConstFamilyNamePool_str1720[sizeof("montserrat underline")]; + char FcConstFamilyNamePool_str1721[sizeof("noto sans nag mundari")]; + char FcConstFamilyNamePool_str1725[sizeof("noto fangsong kss vertical")]; + char FcConstFamilyNamePool_str1733[sizeof("lpfont")]; + char FcConstFamilyNamePool_str1738[sizeof("noto serif toto")]; + char FcConstFamilyNamePool_str1750[sizeof("noto serif armenian")]; + char FcConstFamilyNamePool_str1751[sizeof("minion math")]; + char FcConstFamilyNamePool_str1753[sizeof("3270 nerd font mono")]; + char FcConstFamilyNamePool_str1758[sizeof("noto sans glagolitic")]; + char FcConstFamilyNamePool_str1759[sizeof("kokila")]; + char FcConstFamilyNamePool_str1765[sizeof("fira code")]; + char FcConstFamilyNamePool_str1775[sizeof("jg laotimes")]; + char FcConstFamilyNamePool_str1777[sizeof("drift")]; + char FcConstFamilyNamePool_str1778[sizeof("lateef")]; + char FcConstFamilyNamePool_str1779[sizeof("koodak")]; + char FcConstFamilyNamePool_str1795[sizeof("sazanami gothic")]; + char FcConstFamilyNamePool_str1797[sizeof("android emoji")]; + char FcConstFamilyNamePool_str1807[sizeof("noto sans khmer")]; + char FcConstFamilyNamePool_str1822[sizeof("lohit bengali")]; + char FcConstFamilyNamePool_str1825[sizeof("noto sans georgian ui")]; + char FcConstFamilyNamePool_str1826[sizeof("noto sans kaithi")]; + char FcConstFamilyNamePool_str1836[sizeof("lisu")]; + char FcConstFamilyNamePool_str1841[sizeof("noto serif ottoman siyaq")]; + char FcConstFamilyNamePool_str1849[sizeof("space grotesk")]; + char FcConstFamilyNamePool_str1851[sizeof("noto sans math")]; + char FcConstFamilyNamePool_str1860[sizeof("figtree")]; + char FcConstFamilyNamePool_str1868[sizeof("noto sans hanunoo")]; + char FcConstFamilyNamePool_str1871[sizeof("noto sans adlam unjoined")]; + char FcConstFamilyNamePool_str1877[sizeof("noto serif lao")]; + char FcConstFamilyNamePool_str1879[sizeof("roya")]; + char FcConstFamilyNamePool_str1882[sizeof("kacstdigital")]; + char FcConstFamilyNamePool_str1890[sizeof("sparks dot large")]; + char FcConstFamilyNamePool_str1895[sizeof("noto sans thai ui")]; + char FcConstFamilyNamePool_str1896[sizeof("gfs garaldus")]; + char FcConstFamilyNamePool_str1900[sizeof("signfont")]; + char FcConstFamilyNamePool_str1901[sizeof("nachlieli clm")]; + char FcConstFamilyNamePool_str1904[sizeof("noto color emoji")]; + char FcConstFamilyNamePool_str1907[sizeof("comic neue angular")]; + char FcConstFamilyNamePool_str1908[sizeof("meiryo")]; + char FcConstFamilyNamePool_str1914[sizeof("noto sans chakma")]; + char FcConstFamilyNamePool_str1915[sizeof("source han mono")]; + char FcConstFamilyNamePool_str1927[sizeof("noto sans tirhuta")]; + char FcConstFamilyNamePool_str1944[sizeof("ms ui gothic")]; + char FcConstFamilyNamePool_str1951[sizeof("lohit konkani")]; + char FcConstFamilyNamePool_str1957[sizeof("segoe ui emoji")]; + char FcConstFamilyNamePool_str1959[sizeof("monoid nerd font")]; + char FcConstFamilyNamePool_str1961[sizeof("noto sans saurashtra")]; + char FcConstFamilyNamePool_str1965[sizeof("arimo nerd font")]; + char FcConstFamilyNamePool_str1969[sizeof("gf zemen unicode")]; + char FcConstFamilyNamePool_str1985[sizeof("lklug")]; + char FcConstFamilyNamePool_str1986[sizeof("sparks dot small")]; + char FcConstFamilyNamePool_str1998[sizeof("ungungseo")]; + char FcConstFamilyNamePool_str2003[sizeof("tinos nerd font")]; + char FcConstFamilyNamePool_str2005[sizeof("nafees nastaleeq")]; + char FcConstFamilyNamePool_str2018[sizeof("twitter color emoji")]; + char FcConstFamilyNamePool_str2022[sizeof("mononoki nerd font")]; + char FcConstFamilyNamePool_str2025[sizeof("noto sans yi")]; + char FcConstFamilyNamePool_str2026[sizeof("noto sans lisu")]; + char FcConstFamilyNamePool_str2030[sizeof("lohit kashmiri")]; + char FcConstFamilyNamePool_str2035[sizeof("inconsolata regular")]; + char FcConstFamilyNamePool_str2037[sizeof("ibm 3270 nerd font")]; + char FcConstFamilyNamePool_str2038[sizeof("lohit marathi")]; + char FcConstFamilyNamePool_str2040[sizeof("terminess nerd font")]; + char FcConstFamilyNamePool_str2045[sizeof("noto sans cherokee")]; + char FcConstFamilyNamePool_str2047[sizeof("lohit gujarati")]; + char FcConstFamilyNamePool_str2055[sizeof("lucida sans unicode")]; + char FcConstFamilyNamePool_str2058[sizeof("namdhinggo sil")]; + char FcConstFamilyNamePool_str2062[sizeof("notomono nerd font")]; + char FcConstFamilyNamePool_str2065[sizeof("gfs neohellenic")]; + char FcConstFamilyNamePool_str2069[sizeof("gfs orpheus")]; + char FcConstFamilyNamePool_str2093[sizeof("noto sans oriya")]; + char FcConstFamilyNamePool_str2094[sizeof("spark dot-line thin")]; + char FcConstFamilyNamePool_str2095[sizeof("source han sans cn")]; + char FcConstFamilyNamePool_str2126[sizeof("edwin")]; + char FcConstFamilyNamePool_str2133[sizeof("spacemono nerd font")]; + char FcConstFamilyNamePool_str2144[sizeof("noto sans myanmar")]; + char FcConstFamilyNamePool_str2152[sizeof("noto sans osmanya")]; + char FcConstFamilyNamePool_str2155[sizeof("century gothic")]; + char FcConstFamilyNamePool_str2159[sizeof("latin modern math")]; + char FcConstFamilyNamePool_str2161[sizeof("hasklig")]; + char FcConstFamilyNamePool_str2162[sizeof("jadid")]; + char FcConstFamilyNamePool_str2163[sizeof("sharetechmono nerd font")]; + char FcConstFamilyNamePool_str2165[sizeof("malayalam")]; + char FcConstFamilyNamePool_str2174[sizeof("anka/coder condensed")]; + char FcConstFamilyNamePool_str2178[sizeof("waree")]; + char FcConstFamilyNamePool_str2179[sizeof("noto serif tamil")]; + char FcConstFamilyNamePool_str2181[sizeof("noto sans ol chiki")]; + char FcConstFamilyNamePool_str2188[sizeof("noto sans myanmar ui")]; + char FcConstFamilyNamePool_str2189[sizeof("khmer os muol")]; + char FcConstFamilyNamePool_str2191[sizeof("noto looped thai ui")]; + char FcConstFamilyNamePool_str2192[sizeof("stfangsong")]; + char FcConstFamilyNamePool_str2197[sizeof("alexander")]; + char FcConstFamilyNamePool_str2199[sizeof("gfs orpheus sans")]; + char FcConstFamilyNamePool_str2206[sizeof("adwaita mono")]; + char FcConstFamilyNamePool_str2207[sizeof("meslo nerd font")]; + char FcConstFamilyNamePool_str2208[sizeof("yudit")]; + char FcConstFamilyNamePool_str2209[sizeof("source han mono sc")]; + char FcConstFamilyNamePool_str2210[sizeof("ipaex\346\230\216\346\234\235")]; + char FcConstFamilyNamePool_str2213[sizeof("nanumgothiccoding")]; + char FcConstFamilyNamePool_str2217[sizeof("terafik")]; + char FcConstFamilyNamePool_str2219[sizeof("adwaita sans")]; + char FcConstFamilyNamePool_str2225[sizeof("ume gothic o5")]; + char FcConstFamilyNamePool_str2226[sizeof("lohit sindhi")]; + char FcConstFamilyNamePool_str2229[sizeof("ume gothic s4")]; + char FcConstFamilyNamePool_str2231[sizeof("source han mono tc")]; + char FcConstFamilyNamePool_str2232[sizeof("nanumgothic_coding")]; + char FcConstFamilyNamePool_str2233[sizeof("ume gothic s5")]; + char FcConstFamilyNamePool_str2239[sizeof("fangsong ti")]; + char FcConstFamilyNamePool_str2242[sizeof("unjamosora")]; + char FcConstFamilyNamePool_str2249[sizeof("signfont z")]; + char FcConstFamilyNamePool_str2253[sizeof("ume gothic")]; + char FcConstFamilyNamePool_str2259[sizeof("futura")]; + char FcConstFamilyNamePool_str2261[sizeof("stam sefarad clm")]; + char FcConstFamilyNamePool_str2264[sizeof("noto serif dogra")]; + char FcConstFamilyNamePool_str2276[sizeof("avenir next")]; + char FcConstFamilyNamePool_str2278[sizeof("noto serif tamil slanted")]; + char FcConstFamilyNamePool_str2279[sizeof("frutiger")]; + char FcConstFamilyNamePool_str2281[sizeof("noto sans medefaidrin")]; + char FcConstFamilyNamePool_str2282[sizeof("ia writer mono")]; + char FcConstFamilyNamePool_str2286[sizeof("lohit maithili")]; + char FcConstFamilyNamePool_str2294[sizeof("gomono nerd font")]; + char FcConstFamilyNamePool_str2295[sizeof("emojione mozilla")]; + char FcConstFamilyNamePool_str2301[sizeof("noto sans newa")]; + char FcConstFamilyNamePool_str2320[sizeof("ipaex\343\202\264\343\202\267\343\203\203\343\202\257")]; + char FcConstFamilyNamePool_str2323[sizeof("news cycle")]; + char FcConstFamilyNamePool_str2326[sizeof("lucida math")]; + char FcConstFamilyNamePool_str2327[sizeof("ume gothic c4")]; + char FcConstFamilyNamePool_str2331[sizeof("ume gothic c5")]; + char FcConstFamilyNamePool_str2332[sizeof("noto sans rejang")]; + char FcConstFamilyNamePool_str2335[sizeof("oxygen mono")]; + char FcConstFamilyNamePool_str2336[sizeof("noto sans syriac eastern")]; + char FcConstFamilyNamePool_str2340[sizeof("noto sans syriac")]; + char FcConstFamilyNamePool_str2342[sizeof("sparks dot medium")]; + char FcConstFamilyNamePool_str2352[sizeof("go mono nerd font")]; + char FcConstFamilyNamePool_str2354[sizeof("spark dot-line medium")]; + char FcConstFamilyNamePool_str2356[sizeof("oxygen-sans")]; + char FcConstFamilyNamePool_str2362[sizeof("p052")]; + char FcConstFamilyNamePool_str2365[sizeof("geistmono nerd font")]; + char FcConstFamilyNamePool_str2372[sizeof("yu gothic")]; + char FcConstFamilyNamePool_str2373[sizeof("pt mono")]; + char FcConstFamilyNamePool_str2374[sizeof("sf pro")]; + char FcConstFamilyNamePool_str2381[sizeof("inconsolata nerd font")]; + char FcConstFamilyNamePool_str2382[sizeof("motoyalcedar")]; + char FcConstFamilyNamePool_str2383[sizeof("pt sans")]; + char FcConstFamilyNamePool_str2384[sizeof("luxi mono")]; + char FcConstFamilyNamePool_str2385[sizeof("plantin")]; + char FcConstFamilyNamePool_str2387[sizeof("hack")]; + char FcConstFamilyNamePool_str2392[sizeof("luxi sans")]; + char FcConstFamilyNamePool_str2394[sizeof("sampige")]; + char FcConstFamilyNamePool_str2405[sizeof("ubuntu")]; + char FcConstFamilyNamePool_str2409[sizeof("myriad pro")]; + char FcConstFamilyNamePool_str2410[sizeof("minion pro")]; + char FcConstFamilyNamePool_str2415[sizeof("noto serif georgian")]; + char FcConstFamilyNamePool_str2416[sizeof("unshinmun")]; + char FcConstFamilyNamePool_str2425[sizeof("overpass")]; + char FcConstFamilyNamePool_str2429[sizeof("sathu")]; + char FcConstFamilyNamePool_str2432[sizeof("crimson text")]; + char FcConstFamilyNamePool_str2438[sizeof("news gothic")]; + char FcConstFamilyNamePool_str2445[sizeof("noto sans lycian")]; + char FcConstFamilyNamePool_str2446[sizeof("noto serif ahom")]; + char FcConstFamilyNamePool_str2455[sizeof("noto sans mahajani")]; + char FcConstFamilyNamePool_str2456[sizeof("noto serif makasar")]; + char FcConstFamilyNamePool_str2460[sizeof("noto serif thai")]; + char FcConstFamilyNamePool_str2463[sizeof("ipaexgothic")]; + char FcConstFamilyNamePool_str2481[sizeof("fantasquesansmono")]; + char FcConstFamilyNamePool_str2492[sizeof("campania")]; + char FcConstFamilyNamePool_str2493[sizeof("prociono")]; + char FcConstFamilyNamePool_str2494[sizeof("source serif 4")]; + char FcConstFamilyNamePool_str2495[sizeof("impact")]; + char FcConstFamilyNamePool_str2499[sizeof("drugulinclm")]; + char FcConstFamilyNamePool_str2500[sizeof("fangsong")]; + char FcConstFamilyNamePool_str2507[sizeof("droidsansmono nerd font")]; + char FcConstFamilyNamePool_str2510[sizeof("tlwgmono")]; + char FcConstFamilyNamePool_str2512[sizeof("overpass mono")]; + char FcConstFamilyNamePool_str2518[sizeof("ipapmincho")]; + char FcConstFamilyNamePool_str2521[sizeof("abyssinica sil")]; + char FcConstFamilyNamePool_str2534[sizeof("perizia")]; + char FcConstFamilyNamePool_str2537[sizeof("tlwgtypo")]; + char FcConstFamilyNamePool_str2541[sizeof("droidsansm nerd font")]; + char FcConstFamilyNamePool_str2545[sizeof("jg lao old arial")]; + char FcConstFamilyNamePool_str2552[sizeof("accanthis adf std")]; + char FcConstFamilyNamePool_str2556[sizeof("kacstoffice")]; + char FcConstFamilyNamePool_str2559[sizeof("gfs jackson")]; + char FcConstFamilyNamePool_str2563[sizeof("kacstnaskh")]; + char FcConstFamilyNamePool_str2574[sizeof("ukij tuz")]; + char FcConstFamilyNamePool_str2580[sizeof("noto sans lydian")]; + char FcConstFamilyNamePool_str2583[sizeof("noto sans old turkic")]; + char FcConstFamilyNamePool_str2586[sizeof("oswald")]; + char FcConstFamilyNamePool_str2589[sizeof("fantasquesansmono nerd font")]; + char FcConstFamilyNamePool_str2605[sizeof("padmaa")]; + char FcConstFamilyNamePool_str2606[sizeof("din pro")]; + char FcConstFamilyNamePool_str2608[sizeof("noto sans elymaic")]; + char FcConstFamilyNamePool_str2617[sizeof("tlwgtypist")]; + char FcConstFamilyNamePool_str2618[sizeof("noto sans cuneiform")]; + char FcConstFamilyNamePool_str2622[sizeof("lexend")]; + char FcConstFamilyNamePool_str2624[sizeof("khmer os metal chrieng")]; + char FcConstFamilyNamePool_str2626[sizeof("noto sans malayalam")]; + char FcConstFamilyNamePool_str2627[sizeof("noto sans khmer ui")]; + char FcConstFamilyNamePool_str2636[sizeof("undinaru")]; + char FcConstFamilyNamePool_str2639[sizeof("petaluma")]; + char FcConstFamilyNamePool_str2645[sizeof("palatino")]; + char FcConstFamilyNamePool_str2646[sizeof("noto sans malayalam ui")]; + char FcConstFamilyNamePool_str2649[sizeof("old standard sfd")]; + char FcConstFamilyNamePool_str2658[sizeof("nanummyeongjo")]; + char FcConstFamilyNamePool_str2661[sizeof("kochi mincho")]; + char FcConstFamilyNamePool_str2667[sizeof("noto sans mono cjk sc")]; + char FcConstFamilyNamePool_str2674[sizeof("noto sans kharoshthi")]; + char FcConstFamilyNamePool_str2678[sizeof("gfs orpheus classic")]; + char FcConstFamilyNamePool_str2679[sizeof("noto serif kannada")]; + char FcConstFamilyNamePool_str2682[sizeof("meiryo ui")]; + char FcConstFamilyNamePool_str2683[sizeof("yudit unicode")]; + char FcConstFamilyNamePool_str2689[sizeof("noto sans mono cjk tc")]; + char FcConstFamilyNamePool_str2697[sizeof("gohu")]; + char FcConstFamilyNamePool_str2701[sizeof("noto sans cjk sc")]; + char FcConstFamilyNamePool_str2703[sizeof("source han sans kr")]; + char FcConstFamilyNamePool_str2704[sizeof("yu mincho")]; + char FcConstFamilyNamePool_str2707[sizeof("akzidenz grotesk")]; + char FcConstFamilyNamePool_str2709[sizeof("pigiarniq")]; + char FcConstFamilyNamePool_str2713[sizeof("ubuntu condensed")]; + char FcConstFamilyNamePool_str2714[sizeof("tlwgtypewriter")]; + char FcConstFamilyNamePool_str2716[sizeof("inconsolatago nerd font")]; + char FcConstFamilyNamePool_str2719[sizeof("noto sans old hungarian")]; + char FcConstFamilyNamePool_str2722[sizeof("conakry")]; + char FcConstFamilyNamePool_str2723[sizeof("noto sans cjk tc")]; + char FcConstFamilyNamePool_str2726[sizeof("hurmit nerd font")]; + char FcConstFamilyNamePool_str2730[sizeof("noto serif sinhala")]; + char FcConstFamilyNamePool_str2744[sizeof("unjamonovel")]; + char FcConstFamilyNamePool_str2748[sizeof("leland text")]; + char FcConstFamilyNamePool_str2749[sizeof("noto serif todhri")]; + char FcConstFamilyNamePool_str2751[sizeof("mgopen canonica")]; + char FcConstFamilyNamePool_str2755[sizeof("gfs porson")]; + char FcConstFamilyNamePool_str2759[sizeof("daddytimemono")]; + char FcConstFamilyNamePool_str2765[sizeof("pragmatapro")]; + char FcConstFamilyNamePool_str2766[sizeof("simple clm")]; + char FcConstFamilyNamePool_str2767[sizeof("kochi gothic")]; + char FcConstFamilyNamePool_str2769[sizeof("foundation icons")]; + char FcConstFamilyNamePool_str2777[sizeof("mgopen modata")]; + char FcConstFamilyNamePool_str2778[sizeof("tex gyre termes")]; + char FcConstFamilyNamePool_str2781[sizeof("gfs pyrsos")]; + char FcConstFamilyNamePool_str2787[sizeof("noto sans syloti nagri")]; + char FcConstFamilyNamePool_str2790[sizeof("noto sans inscriptional pahlavi")]; + char FcConstFamilyNamePool_str2791[sizeof("noto sans inscriptional parthian")]; + char FcConstFamilyNamePool_str2805[sizeof("noto sans gujarati")]; + char FcConstFamilyNamePool_str2824[sizeof("gfs fleischman")]; + char FcConstFamilyNamePool_str2835[sizeof("alef")]; + char FcConstFamilyNamePool_str2838[sizeof("rit keraleeyam")]; + char FcConstFamilyNamePool_str2858[sizeof("noto serif grantha")]; + char FcConstFamilyNamePool_str2860[sizeof("work sans")]; + char FcConstFamilyNamePool_str2863[sizeof("noto sans warang citi")]; + char FcConstFamilyNamePool_str2876[sizeof("noto sans tifinagh air")]; + char FcConstFamilyNamePool_str2878[sizeof("noto sans tifinagh adrar")]; + char FcConstFamilyNamePool_str2879[sizeof("cousine nerd font")]; + char FcConstFamilyNamePool_str2880[sizeof("noto sans tifinagh ahaggar")]; + char FcConstFamilyNamePool_str2881[sizeof("league gothic")]; + char FcConstFamilyNamePool_str2883[sizeof("noto sans tifinagh rhissa ixa")]; + char FcConstFamilyNamePool_str2884[sizeof("widelands")]; + char FcConstFamilyNamePool_str2886[sizeof("noto sans tifinagh agraw imazighen")]; + char FcConstFamilyNamePool_str2887[sizeof("malgun gothic")]; + char FcConstFamilyNamePool_str2891[sizeof("noto serif tangut")]; + char FcConstFamilyNamePool_str2893[sizeof("khmer os system")]; + char FcConstFamilyNamePool_str2900[sizeof("noto serif hentaigana")]; + char FcConstFamilyNamePool_str2901[sizeof("ms serif")]; + char FcConstFamilyNamePool_str2909[sizeof("noto sans tifinagh apt")]; + char FcConstFamilyNamePool_str2912[sizeof("freeserif")]; + char FcConstFamilyNamePool_str2913[sizeof("noto sans oriya ui")]; + char FcConstFamilyNamePool_str2914[sizeof("b612")]; + char FcConstFamilyNamePool_str2915[sizeof("opendyslexicmono")]; + char FcConstFamilyNamePool_str2917[sizeof("noto serif")]; + char FcConstFamilyNamePool_str2922[sizeof("sabon")]; + char FcConstFamilyNamePool_str2923[sizeof("infofont")]; + char FcConstFamilyNamePool_str2927[sizeof("opendyslexic")]; + char FcConstFamilyNamePool_str2928[sizeof("noto sans coptic")]; + char FcConstFamilyNamePool_str2930[sizeof("annapurna sil")]; + char FcConstFamilyNamePool_str2932[sizeof("lekton nerd font")]; + char FcConstFamilyNamePool_str2934[sizeof("symbola")]; + char FcConstFamilyNamePool_str2935[sizeof("noto sans psalter pahlavi")]; + char FcConstFamilyNamePool_str2936[sizeof("al bayan")]; + char FcConstFamilyNamePool_str2945[sizeof("unjamobatang")]; + char FcConstFamilyNamePool_str2950[sizeof("noto sans tifinagh tawellemmet")]; + char FcConstFamilyNamePool_str2952[sizeof("roboto")]; + char FcConstFamilyNamePool_str2953[sizeof("b612 mono")]; + char FcConstFamilyNamePool_str2957[sizeof("khmer mondulkiri")]; + char FcConstFamilyNamePool_str2960[sizeof("mplus nerd font")]; + char FcConstFamilyNamePool_str2963[sizeof("patrick hand")]; + char FcConstFamilyNamePool_str2965[sizeof("thonburi")]; + char FcConstFamilyNamePool_str2966[sizeof("source han mono hc")]; + char FcConstFamilyNamePool_str2977[sizeof("noto znamenny musical notation")]; + char FcConstFamilyNamePool_str2978[sizeof("noto sans mayan numerals")]; + char FcConstFamilyNamePool_str2986[sizeof("ipaexmincho")]; + char FcConstFamilyNamePool_str2989[sizeof("ms sans serif")]; + char FcConstFamilyNamePool_str2991[sizeof("tabassom")]; + char FcConstFamilyNamePool_str3000[sizeof("noto sans imperial aramaic")]; + char FcConstFamilyNamePool_str3001[sizeof("xits math")]; + char FcConstFamilyNamePool_str3002[sizeof("bitter")]; + char FcConstFamilyNamePool_str3009[sizeof("noto sans meetei mayek")]; + char FcConstFamilyNamePool_str3010[sizeof("dancing script")]; + char FcConstFamilyNamePool_str3018[sizeof("opendyslexicmono nerd font")]; + char FcConstFamilyNamePool_str3019[sizeof("hanyisong")]; + char FcConstFamilyNamePool_str3021[sizeof("albany amt")]; + char FcConstFamilyNamePool_str3024[sizeof("roboto mono")]; + char FcConstFamilyNamePool_str3027[sizeof("markazi text")]; + char FcConstFamilyNamePool_str3029[sizeof("cambria")]; + char FcConstFamilyNamePool_str3031[sizeof("unjamodotum")]; + char FcConstFamilyNamePool_str3033[sizeof("cooper std")]; + char FcConstFamilyNamePool_str3034[sizeof("noto sans gunjala gondi")]; + char FcConstFamilyNamePool_str3060[sizeof("avenir next condensed")]; + char FcConstFamilyNamePool_str3068[sizeof("itc bodoni")]; + char FcConstFamilyNamePool_str3074[sizeof("britannic")]; + char FcConstFamilyNamePool_str3075[sizeof("ume ui gothic o5")]; + char FcConstFamilyNamePool_str3083[sizeof("yu gothic ui")]; + char FcConstFamilyNamePool_str3086[sizeof("raavi")]; + char FcConstFamilyNamePool_str3087[sizeof("ume hy gothic o5")]; + char FcConstFamilyNamePool_str3089[sizeof("noto sans signwriting")]; + char FcConstFamilyNamePool_str3100[sizeof("beteckna")]; + char FcConstFamilyNamePool_str3103[sizeof("ume ui gothic")]; + char FcConstFamilyNamePool_str3110[sizeof("b compset")]; + char FcConstFamilyNamePool_str3114[sizeof("noto nastaliq urdu")]; + char FcConstFamilyNamePool_str3115[sizeof("ume hy gothic")]; + char FcConstFamilyNamePool_str3116[sizeof("noto sans tifinagh sil")]; + char FcConstFamilyNamePool_str3118[sizeof("letters laughing")]; + char FcConstFamilyNamePool_str3120[sizeof("bola")]; + char FcConstFamilyNamePool_str3124[sizeof("iosevka")]; + char FcConstFamilyNamePool_str3129[sizeof("unpen")]; + char FcConstFamilyNamePool_str3135[sizeof("badr")]; + char FcConstFamilyNamePool_str3136[sizeof("agave")]; + char FcConstFamilyNamePool_str3141[sizeof("itc stone serif")]; + char FcConstFamilyNamePool_str3145[sizeof("noto sans old persian")]; + char FcConstFamilyNamePool_str3152[sizeof("dubai")]; + char FcConstFamilyNamePool_str3156[sizeof("bodoni")]; + char FcConstFamilyNamePool_str3162[sizeof("ia writer quattro")]; + char FcConstFamilyNamePool_str3169[sizeof("vemana2000")]; + char FcConstFamilyNamePool_str3170[sizeof("agbalumo")]; + char FcConstFamilyNamePool_str3185[sizeof("noto sans cjk kr")]; + char FcConstFamilyNamePool_str3193[sizeof("unyetgul")]; + char FcConstFamilyNamePool_str3194[sizeof("noto serif khmer")]; + char FcConstFamilyNamePool_str3195[sizeof("input mono")]; + char FcConstFamilyNamePool_str3198[sizeof("fontawesome 7 free")]; + char FcConstFamilyNamePool_str3203[sizeof("noto sans wancho")]; + char FcConstFamilyNamePool_str3204[sizeof("noto sans telugu")]; + char FcConstFamilyNamePool_str3205[sizeof("gfs philostratos")]; + char FcConstFamilyNamePool_str3212[sizeof("charis sil compact")]; + char FcConstFamilyNamePool_str3220[sizeof("noto sans nabataean")]; + char FcConstFamilyNamePool_str3227[sizeof("cascadia mono pl")]; + char FcConstFamilyNamePool_str3228[sizeof("noto sans new tai lue")]; + char FcConstFamilyNamePool_str3229[sizeof("libertinus")]; + char FcConstFamilyNamePool_str3233[sizeof("iosevkaterm")]; + char FcConstFamilyNamePool_str3236[sizeof("noto sans vai")]; + char FcConstFamilyNamePool_str3243[sizeof("noto sans tifinagh ghat")]; + char FcConstFamilyNamePool_str3246[sizeof("cascadia mono nf")]; + char FcConstFamilyNamePool_str3248[sizeof("calibri")]; + char FcConstFamilyNamePool_str3249[sizeof("iosevka term")]; + char FcConstFamilyNamePool_str3250[sizeof("noto sans telugu ui")]; + char FcConstFamilyNamePool_str3254[sizeof("ia writer duo")]; + char FcConstFamilyNamePool_str3257[sizeof("elephant")]; + char FcConstFamilyNamePool_str3260[sizeof("noto sans mono cjk kr")]; + char FcConstFamilyNamePool_str3263[sizeof("pothana2000")]; + char FcConstFamilyNamePool_str3272[sizeof("infofont z")]; + char FcConstFamilyNamePool_str3274[sizeof("corbel")]; + char FcConstFamilyNamePool_str3277[sizeof("batang")]; + char FcConstFamilyNamePool_str3279[sizeof("opendyslexic nerd font")]; + char FcConstFamilyNamePool_str3286[sizeof("noto sans hanifi rohingya")]; + char FcConstFamilyNamePool_str3289[sizeof("victormono")]; + char FcConstFamilyNamePool_str3305[sizeof("gfs bodoni")]; + char FcConstFamilyNamePool_str3311[sizeof("victor mono")]; + char FcConstFamilyNamePool_str3312[sizeof("noto serif khitan small script")]; + char FcConstFamilyNamePool_str3314[sizeof("proggyclean")]; + char FcConstFamilyNamePool_str3319[sizeof("lohit malayalam")]; + char FcConstFamilyNamePool_str3323[sizeof("vazirmatn")]; + char FcConstFamilyNamePool_str3325[sizeof("red hat text")]; + char FcConstFamilyNamePool_str3328[sizeof("liberation mono")]; + char FcConstFamilyNamePool_str3331[sizeof("vrinda")]; + char FcConstFamilyNamePool_str3336[sizeof("verdana")]; + char FcConstFamilyNamePool_str3341[sizeof("noto sans arabic")]; + char FcConstFamilyNamePool_str3346[sizeof("liberation sans")]; + char FcConstFamilyNamePool_str3356[sizeof("linux libertine")]; + char FcConstFamilyNamePool_str3359[sizeof("noto sans old permic")]; + char FcConstFamilyNamePool_str3360[sizeof("unpilgia")]; + char FcConstFamilyNamePool_str3368[sizeof("inter variable")]; + char FcConstFamilyNamePool_str3375[sizeof("bellota")]; + char FcConstFamilyNamePool_str3376[sizeof("monofur nerd font")]; + char FcConstFamilyNamePool_str3385[sizeof("source han mono k")]; + char FcConstFamilyNamePool_str3387[sizeof("noto sans avestan")]; + char FcConstFamilyNamePool_str3392[sizeof("firamono nerd font")]; + char FcConstFamilyNamePool_str3398[sizeof("spark dot-line extrathin")]; + char FcConstFamilyNamePool_str3402[sizeof("gb_ss_gb18030")]; + char FcConstFamilyNamePool_str3405[sizeof("noto sans elbasan")]; + char FcConstFamilyNamePool_str3409[sizeof("droid serif")]; + char FcConstFamilyNamePool_str3412[sizeof("rockwell")]; + char FcConstFamilyNamePool_str3413[sizeof("stevehand")]; + char FcConstFamilyNamePool_str3429[sizeof("noto sans nko unjoined")]; + char FcConstFamilyNamePool_str3432[sizeof("khmer os muol light")]; + char FcConstFamilyNamePool_str3438[sizeof("linux libertine mono")]; + char FcConstFamilyNamePool_str3462[sizeof("sakkal majalla")]; + char FcConstFamilyNamePool_str3466[sizeof("tex gyre heros")]; + char FcConstFamilyNamePool_str3468[sizeof("noto sans tai viet")]; + char FcConstFamilyNamePool_str3472[sizeof("noto sans balinese")]; + char FcConstFamilyNamePool_str3473[sizeof("liberationmono nerd font")]; + char FcConstFamilyNamePool_str3474[sizeof("source han serif cn")]; + char FcConstFamilyNamePool_str3475[sizeof("urdu nastaliq unicode")]; + char FcConstFamilyNamePool_str3480[sizeof("noto serif oriya")]; + char FcConstFamilyNamePool_str3487[sizeof("emoji two")]; + char FcConstFamilyNamePool_str3497[sizeof("ubuntu nerd font")]; + char FcConstFamilyNamePool_str3500[sizeof("cumberland amt")]; + char FcConstFamilyNamePool_str3505[sizeof("digna's handwriting")]; + char FcConstFamilyNamePool_str3507[sizeof("new athena unicode")]; + char FcConstFamilyNamePool_str3515[sizeof("firacode nerd font")]; + char FcConstFamilyNamePool_str3516[sizeof("firacode nerd font mono")]; + char FcConstFamilyNamePool_str3524[sizeof("noto sans phoenician")]; + char FcConstFamilyNamePool_str3526[sizeof("motoyalmaru")]; + char FcConstFamilyNamePool_str3531[sizeof("noto serif myanmar")]; + char FcConstFamilyNamePool_str3532[sizeof("gohu nerd font")]; + char FcConstFamilyNamePool_str3543[sizeof("spark dot-line thick")]; + char FcConstFamilyNamePool_str3550[sizeof("tex gyre cursor")]; + char FcConstFamilyNamePool_str3562[sizeof("vl gothic")]; + char FcConstFamilyNamePool_str3581[sizeof("noto sans zanabazar square")]; + char FcConstFamilyNamePool_str3583[sizeof("cumberland")]; + char FcConstFamilyNamePool_str3584[sizeof("noto sans gujarati ui")]; + char FcConstFamilyNamePool_str3591[sizeof("noto sans lao looped")]; + char FcConstFamilyNamePool_str3593[sizeof("unifrakturmaguntia")]; + char FcConstFamilyNamePool_str3596[sizeof("cascadia code pl")]; + char FcConstFamilyNamePool_str3597[sizeof("ubuntumono nerd font")]; + char FcConstFamilyNamePool_str3615[sizeof("cascadia code nf")]; + char FcConstFamilyNamePool_str3620[sizeof("noto sans tifinagh")]; + char FcConstFamilyNamePool_str3628[sizeof("tex gyre heros cn")]; + char FcConstFamilyNamePool_str3648[sizeof("noto sans tifinagh azawagh")]; + char FcConstFamilyNamePool_str3650[sizeof("noto sans ethiopic")]; + char FcConstFamilyNamePool_str3656[sizeof("proggysquarettsz")]; + char FcConstFamilyNamePool_str3664[sizeof("delphine")]; + char FcConstFamilyNamePool_str3681[sizeof("franklin gothic")]; + char FcConstFamilyNamePool_str3683[sizeof("unbom")]; + char FcConstFamilyNamePool_str3688[sizeof("noto sans gurmukhi")]; + char FcConstFamilyNamePool_str3690[sizeof("apparatus sil")]; + char FcConstFamilyNamePool_str3694[sizeof("tai heritage pro")]; + char FcConstFamilyNamePool_str3696[sizeof("noto sans lepcha")]; + char FcConstFamilyNamePool_str3700[sizeof("tajawal")]; + char FcConstFamilyNamePool_str3708[sizeof("noto sans tamil supplement")]; + char FcConstFamilyNamePool_str3712[sizeof("khmer os fasthand")]; + char FcConstFamilyNamePool_str3714[sizeof("khmer os freehand")]; + char FcConstFamilyNamePool_str3716[sizeof("ipapgothic")]; + char FcConstFamilyNamePool_str3725[sizeof("noto sans bengali")]; + char FcConstFamilyNamePool_str3726[sizeof("hasklug nerd font")]; + char FcConstFamilyNamePool_str3728[sizeof("andika compact")]; + char FcConstFamilyNamePool_str3737[sizeof("dai banna sil")]; + char FcConstFamilyNamePool_str3748[sizeof("nimbus mono")]; + char FcConstFamilyNamePool_str3753[sizeof("pcfont")]; + char FcConstFamilyNamePool_str3759[sizeof("profont")]; + char FcConstFamilyNamePool_str3761[sizeof("nimbus roman")]; + char FcConstFamilyNamePool_str3767[sizeof("source code pro")]; + char FcConstFamilyNamePool_str3769[sizeof("nimbus sans")]; + char FcConstFamilyNamePool_str3771[sizeof("noto sans bengali ui")]; + char FcConstFamilyNamePool_str3778[sizeof("bauer bodoni")]; + char FcConstFamilyNamePool_str3791[sizeof("tex gyre schola")]; + char FcConstFamilyNamePool_str3799[sizeof("itc bookman")]; + char FcConstFamilyNamePool_str3803[sizeof("fixedsys")]; + char FcConstFamilyNamePool_str3827[sizeof("stix two math")]; + char FcConstFamilyNamePool_str3835[sizeof("david clm")]; + char FcConstFamilyNamePool_str3838[sizeof("noto sans khojki")]; + char FcConstFamilyNamePool_str3844[sizeof("lohit telugu")]; + char FcConstFamilyNamePool_str3849[sizeof("vazirmatn nl")]; + char FcConstFamilyNamePool_str3853[sizeof("traditional arabic")]; + char FcConstFamilyNamePool_str3866[sizeof("noto sans kayah li")]; + char FcConstFamilyNamePool_str3867[sizeof("trebuchet ms")]; + char FcConstFamilyNamePool_str3878[sizeof("noto sans bamum")]; + char FcConstFamilyNamePool_str3880[sizeof("univers")]; + char FcConstFamilyNamePool_str3881[sizeof("vazirmatn rd")]; + char FcConstFamilyNamePool_str3890[sizeof("noto sans tifinagh hawad")]; + char FcConstFamilyNamePool_str3895[sizeof("noto sans brahmi")]; + char FcConstFamilyNamePool_str3900[sizeof("sparks dot extrasmall")]; + char FcConstFamilyNamePool_str3901[sizeof("zapfino")]; + char FcConstFamilyNamePool_str3927[sizeof("yehudaclm")]; + char FcConstFamilyNamePool_str3937[sizeof("gillius adf")]; + char FcConstFamilyNamePool_str3939[sizeof("ethiopic washra")]; + char FcConstFamilyNamePool_str3941[sizeof("noto serif yezidi")]; + char FcConstFamilyNamePool_str3943[sizeof("ar pl new sung mono")]; + char FcConstFamilyNamePool_str3961[sizeof("noto sans devanagari")]; + char FcConstFamilyNamePool_str3963[sizeof("unpenheulim")]; + char FcConstFamilyNamePool_str3964[sizeof("noto sans devanagari ui")]; + char FcConstFamilyNamePool_str3992[sizeof("arundina serif")]; + char FcConstFamilyNamePool_str3998[sizeof("baskerville")]; + char FcConstFamilyNamePool_str4002[sizeof("fixed")]; + char FcConstFamilyNamePool_str4005[sizeof("droid sans ethiopic")]; + char FcConstFamilyNamePool_str4008[sizeof("sf pro rounded")]; + char FcConstFamilyNamePool_str4010[sizeof("sparks dot extralarge")]; + char FcConstFamilyNamePool_str4013[sizeof("roboto condensed")]; + char FcConstFamilyNamePool_str4019[sizeof("noto serif malayalam")]; + char FcConstFamilyNamePool_str4028[sizeof("noto sans mono cjk hk")]; + char FcConstFamilyNamePool_str4034[sizeof("noto sans arabic ui")]; + char FcConstFamilyNamePool_str4054[sizeof("keyfont v2")]; + char FcConstFamilyNamePool_str4056[sizeof("gfs bodoni classic")]; + char FcConstFamilyNamePool_str4063[sizeof("bpg utf8 m")]; + char FcConstFamilyNamePool_str4064[sizeof("saysettha unicode")]; + char FcConstFamilyNamePool_str4068[sizeof("padauk")]; + char FcConstFamilyNamePool_str4072[sizeof("navilu")]; + char FcConstFamilyNamePool_str4078[sizeof("noto naskh arabic ui")]; + char FcConstFamilyNamePool_str4080[sizeof("source han serif kr")]; + char FcConstFamilyNamePool_str4088[sizeof("noto serif cjk sc")]; + char FcConstFamilyNamePool_str4091[sizeof("unvada")]; + char FcConstFamilyNamePool_str4097[sizeof("noto sans shavian")]; + char FcConstFamilyNamePool_str4102[sizeof("pcfont z")]; + char FcConstFamilyNamePool_str4106[sizeof("ume p mincho")]; + char FcConstFamilyNamePool_str4110[sizeof("noto serif cjk tc")]; + char FcConstFamilyNamePool_str4114[sizeof("spark dot-line extrathick")]; + char FcConstFamilyNamePool_str4137[sizeof("stix")]; + char FcConstFamilyNamePool_str4141[sizeof("gentium plus compact")]; + char FcConstFamilyNamePool_str4143[sizeof("noto naskh arabic")]; + char FcConstFamilyNamePool_str4145[sizeof("vazirmatn ui")]; + char FcConstFamilyNamePool_str4158[sizeof("raleway")]; + char FcConstFamilyNamePool_str4161[sizeof("vazirmatn rd nl")]; + char FcConstFamilyNamePool_str4164[sizeof("apple color emoji")]; + char FcConstFamilyNamePool_str4174[sizeof("noto serif gujarati")]; + char FcConstFamilyNamePool_str4176[sizeof("ar pl new sung")]; + char FcConstFamilyNamePool_str4178[sizeof("inconsolata bold")]; + char FcConstFamilyNamePool_str4180[sizeof("ume p mincho s3")]; + char FcConstFamilyNamePool_str4184[sizeof("ume p gothic o5")]; + char FcConstFamilyNamePool_str4188[sizeof("ume p gothic s4")]; + char FcConstFamilyNamePool_str4189[sizeof("haettenschweiler")]; + char FcConstFamilyNamePool_str4192[sizeof("ume p gothic s5")]; + char FcConstFamilyNamePool_str4201[sizeof("krungthep")]; + char FcConstFamilyNamePool_str4209[sizeof("entypo")]; + char FcConstFamilyNamePool_str4212[sizeof("ume p gothic")]; + char FcConstFamilyNamePool_str4218[sizeof("pmingliu")]; + char FcConstFamilyNamePool_str4225[sizeof("brandon grotesque")]; + char FcConstFamilyNamePool_str4228[sizeof("frank ruehl")]; + char FcConstFamilyNamePool_str4230[sizeof("linux biolinum")]; + char FcConstFamilyNamePool_str4234[sizeof("urw gothic")]; + char FcConstFamilyNamePool_str4243[sizeof("helvetica")]; + char FcConstFamilyNamePool_str4248[sizeof("ar pl zenkai uni")]; + char FcConstFamilyNamePool_str4250[sizeof("nimbus mono l")]; + char FcConstFamilyNamePool_str4257[sizeof("lohit gurmukhi")]; + char FcConstFamilyNamePool_str4259[sizeof("noto sans pau cin hau")]; + char FcConstFamilyNamePool_str4263[sizeof("nimbus sans l")]; + char FcConstFamilyNamePool_str4280[sizeof("vollkorn")]; + char FcConstFamilyNamePool_str4286[sizeof("ume p gothic c4")]; + char FcConstFamilyNamePool_str4290[sizeof("ume p gothic c5")]; + char FcConstFamilyNamePool_str4291[sizeof("rit meera new")]; + char FcConstFamilyNamePool_str4292[sizeof("kacstdecorative")]; + char FcConstFamilyNamePool_str4305[sizeof("overpass nerd font")]; + char FcConstFamilyNamePool_str4307[sizeof("antykwatorunska")]; + char FcConstFamilyNamePool_str4317[sizeof("noto sans syriac western")]; + char FcConstFamilyNamePool_str4318[sizeof("noto sans ethiopic ui")]; + char FcConstFamilyNamePool_str4324[sizeof("microsoft yahei")]; + char FcConstFamilyNamePool_str4329[sizeof("tex gyre chorus")]; + char FcConstFamilyNamePool_str4332[sizeof("noto sans buginese")]; + char FcConstFamilyNamePool_str4336[sizeof("rubik")]; + char FcConstFamilyNamePool_str4337[sizeof("apple sd gothic neo")]; + char FcConstFamilyNamePool_str4357[sizeof("nimbus roman no9 l")]; + char FcConstFamilyNamePool_str4361[sizeof("im writing nerd font mono")]; + char FcConstFamilyNamePool_str4381[sizeof("biaukai")]; + char FcConstFamilyNamePool_str4386[sizeof("im writing nerd font")]; + char FcConstFamilyNamePool_str4390[sizeof("unbatang")]; + char FcConstFamilyNamePool_str4396[sizeof("stix two text")]; + char FcConstFamilyNamePool_str4417[sizeof("jetbrains mono")]; + char FcConstFamilyNamePool_str4427[sizeof("droid sans devanagari")]; + char FcConstFamilyNamePool_str4432[sizeof("antykwatorunska medium")]; + char FcConstFamilyNamePool_str4438[sizeof("frank ruehl clm")]; + char FcConstFamilyNamePool_str4443[sizeof("gentium book basic")]; + char FcConstFamilyNamePool_str4448[sizeof("armnet helvetica")]; + char FcConstFamilyNamePool_str4455[sizeof("droid sans japanese")]; + char FcConstFamilyNamePool_str4457[sizeof("vazirmatn rd ui")]; + char FcConstFamilyNamePool_str4461[sizeof("lilex nerd font")]; + char FcConstFamilyNamePool_str4467[sizeof("noto sans gurmukhi ui")]; + char FcConstFamilyNamePool_str4473[sizeof("arial hebrew")]; + char FcConstFamilyNamePool_str4477[sizeof("gfs complutum")]; + char FcConstFamilyNamePool_str4483[sizeof("tobecontinued")]; + char FcConstFamilyNamePool_str4485[sizeof("baekmuk batang")]; + char FcConstFamilyNamePool_str4486[sizeof("gelly")]; + char FcConstFamilyNamePool_str4500[sizeof("ibmplexmono nerd font")]; + char FcConstFamilyNamePool_str4506[sizeof("ibm plex mono")]; + char FcConstFamilyNamePool_str4507[sizeof("cordia new")]; + char FcConstFamilyNamePool_str4511[sizeof("book antiqua")]; + char FcConstFamilyNamePool_str4513[sizeof("khmer os bokor")]; + char FcConstFamilyNamePool_str4516[sizeof("umeplus gothic")]; + char FcConstFamilyNamePool_str4519[sizeof("antykwatorunskacond medium")]; + char FcConstFamilyNamePool_str4524[sizeof("ibm plex sans")]; + char FcConstFamilyNamePool_str4527[sizeof("aegyptus")]; + char FcConstFamilyNamePool_str4528[sizeof("goudy bookletter 1911")]; + char FcConstFamilyNamePool_str4544[sizeof("khmer os muol pali")]; + char FcConstFamilyNamePool_str4545[sizeof("antykwatorunskacond light")]; + char FcConstFamilyNamePool_str4550[sizeof("noto sans cypro minoan")]; + char FcConstFamilyNamePool_str4553[sizeof("daddytimemono nerd font")]; + char FcConstFamilyNamePool_str4557[sizeof("sf pro text")]; + char FcConstFamilyNamePool_str4559[sizeof("noto sans cypriot")]; + char FcConstFamilyNamePool_str4563[sizeof("noto sans batak")]; + char FcConstFamilyNamePool_str4569[sizeof("new peninim mt")]; + char FcConstFamilyNamePool_str4571[sizeof("baekmuk dotum")]; + char FcConstFamilyNamePool_str4572[sizeof("noto serif cjk kr")]; + char FcConstFamilyNamePool_str4576[sizeof("hiragino mincho pron")]; + char FcConstFamilyNamePool_str4591[sizeof("noto serif telugu")]; + char FcConstFamilyNamePool_str4593[sizeof("snap")]; + char FcConstFamilyNamePool_str4614[sizeof("fontawesome 7 brands")]; + char FcConstFamilyNamePool_str4616[sizeof("noto serif tibetan")]; + char FcConstFamilyNamePool_str4630[sizeof("lilex")]; + char FcConstFamilyNamePool_str4646[sizeof("umpush")]; + char FcConstFamilyNamePool_str4649[sizeof("perpetua")]; + char FcConstFamilyNamePool_str4666[sizeof("noto sans cjk hk")]; + char FcConstFamilyNamePool_str4671[sizeof("vazirmatn ui nl")]; + char FcConstFamilyNamePool_str4677[sizeof("pingfang sc")]; + char FcConstFamilyNamePool_str4684[sizeof("noto sans palmyrene")]; + char FcConstFamilyNamePool_str4688[sizeof("cambria math")]; + char FcConstFamilyNamePool_str4692[sizeof("hoefler text")]; + char FcConstFamilyNamePool_str4699[sizeof("pingfang tc")]; + char FcConstFamilyNamePool_str4706[sizeof("albany")]; + char FcConstFamilyNamePool_str4707[sizeof("noto kufi arabic")]; + char FcConstFamilyNamePool_str4725[sizeof("antykwatorunskacond")]; + char FcConstFamilyNamePool_str4732[sizeof("lucidatypewriter")]; + char FcConstFamilyNamePool_str4750[sizeof("noto sans javanese")]; + char FcConstFamilyNamePool_str4758[sizeof("dejavu sans")]; + char FcConstFamilyNamePool_str4762[sizeof("baekmuk gulim")]; + char FcConstFamilyNamePool_str4765[sizeof("lucida bright")]; + char FcConstFamilyNamePool_str4785[sizeof("anonymicepro nerd font mono")]; + char FcConstFamilyNamePool_str4810[sizeof("anonymicepro nerd font")]; + char FcConstFamilyNamePool_str4814[sizeof("petalumatext")]; + char FcConstFamilyNamePool_str4816[sizeof("noto serif balinese")]; + char FcConstFamilyNamePool_str4821[sizeof("biz udmincho")]; + char FcConstFamilyNamePool_str4833[sizeof("openmoji black")]; + char FcConstFamilyNamePool_str4846[sizeof("tagmukay")]; + char FcConstFamilyNamePool_str4848[sizeof("biz udpmincho")]; + char FcConstFamilyNamePool_str4849[sizeof("noto sans limbu")]; + char FcConstFamilyNamePool_str4870[sizeof("dejavu sans mono")]; + char FcConstFamilyNamePool_str4872[sizeof("sparks bar medium")]; + char FcConstFamilyNamePool_str4884[sizeof("d-din exp")]; + char FcConstFamilyNamePool_str4896[sizeof("umeplus p gothic")]; + char FcConstFamilyNamePool_str4897[sizeof("robotomono nerd font")]; + char FcConstFamilyNamePool_str4908[sizeof("noto serif ethiopic")]; + char FcConstFamilyNamePool_str4909[sizeof("bpg glaho international")]; + char FcConstFamilyNamePool_str4927[sizeof("biz udgothic")]; + char FcConstFamilyNamePool_str4931[sizeof("twentieth century")]; + char FcConstFamilyNamePool_str4945[sizeof("glisp")]; + char FcConstFamilyNamePool_str4953[sizeof("mukti narrow")]; + char FcConstFamilyNamePool_str4966[sizeof("agave nerd font")]; + char FcConstFamilyNamePool_str4970[sizeof("noto sans soyombo")]; + char FcConstFamilyNamePool_str4983[sizeof("vazirmatn rd ui nl")]; + char FcConstFamilyNamePool_str4985[sizeof("dejavusansmono nerd font")]; + char FcConstFamilyNamePool_str4986[sizeof("hiragino kaku gothic")]; + char FcConstFamilyNamePool_str5022[sizeof("iosevka nerd font")]; + char FcConstFamilyNamePool_str5025[sizeof("anonymous pro")]; + char FcConstFamilyNamePool_str5028[sizeof("bauhaus std")]; + char FcConstFamilyNamePool_str5038[sizeof("agave nerd font mono")]; + char FcConstFamilyNamePool_str5041[sizeof("microsoft jhenghei")]; + char FcConstFamilyNamePool_str5045[sizeof("iosevka nerd font mono")]; + char FcConstFamilyNamePool_str5057[sizeof("noto serif gurmukhi")]; + char FcConstFamilyNamePool_str5064[sizeof("envycoder")]; + char FcConstFamilyNamePool_str5067[sizeof("iosevkaterm nerd font")]; + char FcConstFamilyNamePool_str5070[sizeof("courier new")]; + char FcConstFamilyNamePool_str5081[sizeof("itc zapf chancery std")]; + char FcConstFamilyNamePool_str5087[sizeof("noto serif np hmong")]; + char FcConstFamilyNamePool_str5088[sizeof("noto sans khudawadi")]; + char FcConstFamilyNamePool_str5096[sizeof("vdrsymbols sans")]; + char FcConstFamilyNamePool_str5112[sizeof("noto serif bengali")]; + char FcConstFamilyNamePool_str5114[sizeof("noto sans buhid")]; + char FcConstFamilyNamePool_str5115[sizeof("applemyungjo")]; + char FcConstFamilyNamePool_str5132[sizeof("luxi serif")]; + char FcConstFamilyNamePool_str5138[sizeof("rit tn joy")]; + char FcConstFamilyNamePool_str5144[sizeof("pt serif")]; + char FcConstFamilyNamePool_str5146[sizeof("microsoft yahei ui")]; + char FcConstFamilyNamePool_str5149[sizeof("barlow")]; + char FcConstFamilyNamePool_str5156[sizeof("proggyclean nerd font")]; + char FcConstFamilyNamePool_str5164[sizeof("sourcecodepro nerd font")]; + char FcConstFamilyNamePool_str5167[sizeof("petalumascript")]; + char FcConstFamilyNamePool_str5176[sizeof("helvetica neue")]; + char FcConstFamilyNamePool_str5184[sizeof("victormono nerd font")]; + char FcConstFamilyNamePool_str5194[sizeof("helvetica lt std")]; + char FcConstFamilyNamePool_str5199[sizeof("petaluma script")]; + char FcConstFamilyNamePool_str5207[sizeof("youyuan")]; + char FcConstFamilyNamePool_str5212[sizeof("noto sans symbols")]; + char FcConstFamilyNamePool_str5225[sizeof("noto serif khojki")]; + char FcConstFamilyNamePool_str5240[sizeof("noto sans symbols 2")]; + char FcConstFamilyNamePool_str5253[sizeof("ar pl uming hk")]; + char FcConstFamilyNamePool_str5266[sizeof("anka/coder narrow")]; + char FcConstFamilyNamePool_str5311[sizeof("biz udpgothic")]; + char FcConstFamilyNamePool_str5330[sizeof("noto serif devanagari")]; + char FcConstFamilyNamePool_str5356[sizeof("new york")]; + char FcConstFamilyNamePool_str5382[sizeof("proggytinyttsz")]; + char FcConstFamilyNamePool_str5404[sizeof("source han serif tw")]; + char FcConstFamilyNamePool_str5426[sizeof("antykwatorunska light")]; + char FcConstFamilyNamePool_str5429[sizeof("liberation sans narrow")]; + char FcConstFamilyNamePool_str5485[sizeof("public sans")]; + char FcConstFamilyNamePool_str5535[sizeof("noto sans tagbanwa")]; + char FcConstFamilyNamePool_str5594[sizeof("laconic-shadow")]; + char FcConstFamilyNamePool_str5599[sizeof("adobe caslon pro")]; + char FcConstFamilyNamePool_str5600[sizeof("noto sans egyptian hieroglyphs")]; + char FcConstFamilyNamePool_str5606[sizeof("ar pl ukai hk")]; + char FcConstFamilyNamePool_str5609[sizeof("khmer os siemreap")]; + char FcConstFamilyNamePool_str5611[sizeof("noto sans vithkuqi")]; + char FcConstFamilyNamePool_str5624[sizeof("profont nerd font")]; + char FcConstFamilyNamePool_str5632[sizeof("noto sans duployan")]; + char FcConstFamilyNamePool_str5662[sizeof("adobe garamond pro")]; + char FcConstFamilyNamePool_str5698[sizeof("beteckna lower case")]; + char FcConstFamilyNamePool_str5703[sizeof("segoe ui symbol")]; + char FcConstFamilyNamePool_str5709[sizeof("saab")]; + char FcConstFamilyNamePool_str5710[sizeof("heavydata")]; + char FcConstFamilyNamePool_str5729[sizeof("tribun adf std")]; + char FcConstFamilyNamePool_str5731[sizeof("goudy old style")]; + char FcConstFamilyNamePool_str5735[sizeof("libre caslon text")]; + char FcConstFamilyNamePool_str5738[sizeof("joypixels")]; + char FcConstFamilyNamePool_str5755[sizeof("tex gyre pagella")]; + char FcConstFamilyNamePool_str5789[sizeof("wenquanyi micro hei")]; + char FcConstFamilyNamePool_str5820[sizeof("microsoft jhenghei ui")]; + char FcConstFamilyNamePool_str5824[sizeof("wenquanyi micro hei mono")]; + char FcConstFamilyNamePool_str5850[sizeof("wenquanyi zen hei")]; + char FcConstFamilyNamePool_str5870[sizeof("noto serif old uyghur")]; + char FcConstFamilyNamePool_str5887[sizeof("paktype tehreer")]; + char FcConstFamilyNamePool_str5900[sizeof("ar pl shanheisun uni")]; + char FcConstFamilyNamePool_str5925[sizeof("fkp")]; + char FcConstFamilyNamePool_str5936[sizeof("caskaydiacove nerd font mono")]; + char FcConstFamilyNamePool_str5961[sizeof("caskaydiacove nerd font")]; + char FcConstFamilyNamePool_str5975[sizeof("noto sans phags pa")]; + char FcConstFamilyNamePool_str5982[sizeof("yanone kaffeesatz")]; + char FcConstFamilyNamePool_str5984[sizeof("droid arabic naskh")]; + char FcConstFamilyNamePool_str5999[sizeof("tex gyre adventor")]; + char FcConstFamilyNamePool_str6031[sizeof("source han sans tw")]; + char FcConstFamilyNamePool_str6038[sizeof("sophia nubian")]; + char FcConstFamilyNamePool_str6048[sizeof("gubbi")]; + char FcConstFamilyNamePool_str6053[sizeof("noto serif cjk hk")]; + char FcConstFamilyNamePool_str6062[sizeof("simplified arabic")]; + char FcConstFamilyNamePool_str6083[sizeof("sparks bar wide")]; + char FcConstFamilyNamePool_str6084[sizeof("nimbus mono ps")]; + char FcConstFamilyNamePool_str6096[sizeof("liberation serif")]; + char FcConstFamilyNamePool_str6108[sizeof("gb_ss_gb18030_extended")]; + char FcConstFamilyNamePool_str6112[sizeof("silkscreen expanded")]; + char FcConstFamilyNamePool_str6123[sizeof("noto sans mono cjk jp")]; + char FcConstFamilyNamePool_str6125[sizeof("noto sans bhaiksuki")]; + char FcConstFamilyNamePool_str6127[sizeof("lohit punjabi")]; + char FcConstFamilyNamePool_str6140[sizeof("beteckna small caps")]; + char FcConstFamilyNamePool_str6147[sizeof("scheherazade new")]; + char FcConstFamilyNamePool_str6176[sizeof("b davat")]; + char FcConstFamilyNamePool_str6185[sizeof("jetbrainsmono nerd font")]; + char FcConstFamilyNamePool_str6190[sizeof("arabic typesetting")]; + char FcConstFamilyNamePool_str6226[sizeof("tex gyre bonum")]; + char FcConstFamilyNamePool_str6227[sizeof("noto sans linear b")]; + char FcConstFamilyNamePool_str6241[sizeof("bitstream vera sans")]; + char FcConstFamilyNamePool_str6263[sizeof("bitstream vera sans mono")]; + char FcConstFamilyNamePool_str6272[sizeof("andika new basic")]; + char FcConstFamilyNamePool_str6275[sizeof("droid sans fallback")]; + char FcConstFamilyNamePool_str6300[sizeof("bitstreamverasansmono nerd font")]; + char FcConstFamilyNamePool_str6316[sizeof("pt serif caption")]; + char FcConstFamilyNamePool_str6333[sizeof("inter display")]; + char FcConstFamilyNamePool_str6452[sizeof("urw bookman")]; + char FcConstFamilyNamePool_str6456[sizeof("tuffy")]; + char FcConstFamilyNamePool_str6512[sizeof("zilla slab highlight")]; + char FcConstFamilyNamePool_str6534[sizeof("droid arabic kufi")]; + char FcConstFamilyNamePool_str6553[sizeof("ar pl mingti2l big5")]; + char FcConstFamilyNamePool_str6557[sizeof("paktype naqsh")]; + char FcConstFamilyNamePool_str6578[sizeof("gb_ss_gb18030_extendedk")]; + char FcConstFamilyNamePool_str6584[sizeof("dejavusansm nerd font")]; + char FcConstFamilyNamePool_str6631[sizeof("zilla slab")]; + char FcConstFamilyNamePool_str6642[sizeof("pingfang hk")]; + char FcConstFamilyNamePool_str6655[sizeof("bravura")]; + char FcConstFamilyNamePool_str6660[sizeof("noto sans display")]; + char FcConstFamilyNamePool_str6708[sizeof("vl pgothic")]; + char FcConstFamilyNamePool_str6745[sizeof("noto sans hebrew ui")]; + char FcConstFamilyNamePool_str6761[sizeof("copperplate gothic std")]; + char FcConstFamilyNamePool_str6863[sizeof("poppins")]; + char FcConstFamilyNamePool_str6924[sizeof("bigblueterminal")]; + char FcConstFamilyNamePool_str6927[sizeof("envycoder nerd font")]; + char FcConstFamilyNamePool_str6943[sizeof("source han serif jp")]; + char FcConstFamilyNamePool_str6948[sizeof("noto sans bassa vah")]; + char FcConstFamilyNamePool_str6980[sizeof("noto serif vithkuqi")]; + char FcConstFamilyNamePool_str7088[sizeof("bigblueterminal nerd font")]; + char FcConstFamilyNamePool_str7089[sizeof("khmer os battambang")]; + char FcConstFamilyNamePool_str7100[sizeof("ar pl uming tw")]; + char FcConstFamilyNamePool_str7162[sizeof("palatino linotype")]; + char FcConstFamilyNamePool_str7204[sizeof("source code vf")]; + char FcConstFamilyNamePool_str7274[sizeof("ibm plex serif")]; + char FcConstFamilyNamePool_str7282[sizeof("noto sans pahawh hmong")]; + char FcConstFamilyNamePool_str7352[sizeof("hiragino sans gb")]; + char FcConstFamilyNamePool_str7354[sizeof("red hat display")]; + char FcConstFamilyNamePool_str7405[sizeof("ektype baloo 2")]; + char FcConstFamilyNamePool_str7415[sizeof("bonvenocf")]; + char FcConstFamilyNamePool_str7453[sizeof("ar pl ukai tw")]; + char FcConstFamilyNamePool_str7457[sizeof("proxima nova")]; + char FcConstFamilyNamePool_str7485[sizeof("dejavu serif")]; + char FcConstFamilyNamePool_str7556[sizeof("ektype baloo tamma 2")]; + char FcConstFamilyNamePool_str7573[sizeof("heavydata nerd font")]; + char FcConstFamilyNamePool_str7579[sizeof("libre baskerville")]; + char FcConstFamilyNamePool_str7611[sizeof("gfs baskerville")]; + char FcConstFamilyNamePool_str7656[sizeof("padauk book")]; + char FcConstFamilyNamePool_str7717[sizeof("ektype baloo da 2")]; + char FcConstFamilyNamePool_str7815[sizeof("source han sans jp")]; + char FcConstFamilyNamePool_str7842[sizeof("sparks bar narrow")]; + char FcConstFamilyNamePool_str7947[sizeof("noto sans hebrew")]; + char FcConstFamilyNamePool_str7958[sizeof("sparks bar extranarrow")]; + char FcConstFamilyNamePool_str7979[sizeof("noto rashi hebrew")]; + char FcConstFamilyNamePool_str8002[sizeof("sparks bar extrawide")]; + char FcConstFamilyNamePool_str8036[sizeof("unikurd web")]; + char FcConstFamilyNamePool_str8047[sizeof("noto serif display")]; + char FcConstFamilyNamePool_str8146[sizeof("hapax berb\303\250re")]; + char FcConstFamilyNamePool_str8174[sizeof("source han code jp")]; + char FcConstFamilyNamePool_str8293[sizeof("be vietnam pro")]; + char FcConstFamilyNamePool_str8297[sizeof("noto sans cjk jp")]; + char FcConstFamilyNamePool_str8431[sizeof("droid sans hebrew")]; + char FcConstFamilyNamePool_str8465[sizeof("ektype baloo chettan 2")]; + char FcConstFamilyNamePool_str8639[sizeof("roboto slab")]; + char FcConstFamilyNamePool_str8822[sizeof("sf pro display")]; + char FcConstFamilyNamePool_str8840[sizeof("bravuratext")]; + char FcConstFamilyNamePool_str8911[sizeof("finale broadway text")]; + char FcConstFamilyNamePool_str8920[sizeof("wenquanyi zen hei sharp")]; + char FcConstFamilyNamePool_str9004[sizeof("bitstream vera serif")]; + char FcConstFamilyNamePool_str9058[sizeof("ektype baloo tammudu 2")]; + char FcConstFamilyNamePool_str9334[sizeof("noto serif hebrew")]; + char FcConstFamilyNamePool_str9480[sizeof("paktype naskh basic wide")]; + char FcConstFamilyNamePool_str9485[sizeof("paktype naskh basic semi wide")]; + char FcConstFamilyNamePool_str9536[sizeof("paktype naskh basic")]; + char FcConstFamilyNamePool_str9684[sizeof("noto serif cjk jp")]; + char FcConstFamilyNamePool_str10060[sizeof("ar pl sungtil gb")]; + char FcConstFamilyNamePool_str10341[sizeof("wenquanyi bitmap song")]; + char FcConstFamilyNamePool_str10494[sizeof("finale broadway")]; + char FcConstFamilyNamePool_str10575[sizeof("m yuppy gb")]; + char FcConstFamilyNamePool_str11056[sizeof("ektype baloo bhai 2")]; + char FcConstFamilyNamePool_str11076[sizeof("ektype baloo bhaina 2")]; + char FcConstFamilyNamePool_str11085[sizeof("ektype baloo paaji 2")]; + char FcConstFamilyNamePool_str11119[sizeof("ektype baloo thambi 2")]; + char FcConstFamilyNamePool_str12005[sizeof("playfair display")]; + }; +static const struct FcConstFamilyNamePool_t FcConstFamilyNamePool_contents = + { + "sina", + "sora", + "amiri", + "raanana", + "asea", + "aroania", + "norasi", + "arimo", + "nsimsun", + "m+ 1mn", + "nasim", + "avenir", + "m+ 1m", + "mononoki", + "meera", + "sf mono", + "nunito", + "manrope", + "m+ 2m", + "mitra", + "optima", + "titr", + "anorexia", + "nirmala ui", + "ibm 3270", + "inter", + "exo 2", + "tinos", + "shimenkan", + "open sans", + "mint mono", + "noto sans", + "miriam mono", + "terminus", + "noto emoji", + "times", + "smoothansi", + "c059", + "\357\275\215\357\275\223 \346\230\216\346\234\235", + "mrs eaves", + "museo sans", + "cairo", + "monaco", + "nunito sans", + "musica", + "clean", + "cure", + "zar", + "mint mono 35", + "charter", + "console", + "operator mono", + "clarendon", + "montserrat", + "noto sans mro", + "consolas", + "z003", + "spacemono", + "aharoniclm", + "miriam clm", + "cormorant", + "noto sans miao", + "noto sans mono", + "\357\275\215\357\275\223 \343\202\264\343\202\267\343\203\203\343\202\257", + "tiza", + "space mono", + "clear sans", + "crimson pro", + "eczar", + "lora", + "muli", + "loma", + "commissioner", + "dror", + "constantia", + "menlo", + "avdira", + "madan", + "lato", + "monoid", + "meslo", + "times new roman", + "monolisa", + "lime", + "madan2", + "sharetechmono", + "mnmlicons", + "dm sans", + "analecta", + "noto sans armenian", + "zysong18030", + "lotoos", + "smonohand", + "itc stone sans", + "notcouriersans", + "noto sans samaritan", + "molot", + "literata", + "noto sans masaram gondi", + "thorndale", + "noto music", + "dustismo", + "noto sans carian", + "epilogue", + "din next", + "comic neue", + "carlito", + "irannastaliq", + "cascadia mono", + "caslon", + "go mono", + "candara", + "aegean", + "stsong", + "cardo", + "tunga", + "simsong", + "comic sans ms", + "gfs olga", + "alegreya", + "noto sans lao", + "segoe ui", + "comicshannsmono", + "awami nastaliq", + "edges", + "nazli", + "geist", + "code2001", + "elliniaclm", + "gfs ignacio", + "noto sans modi", + "intel one mono", + "geist mono", + "code2000", + "inconsolata", + "gfs ambrosia", + "thorndale amt", + "laconic", + "gfs solomos", + "arial", + "codenewroman", + "ipagothic", + "ms gothic", + "d-din", + "gfs artemisia", + "alegreya sans", + "great vibes", + "openmoji color", + "latin modern roman", + "gfs nicefore", + "noto sans linear a", + "ezra sil", + "miriam mono clm", + "terminal", + "songti sc", + "noto sans tai le", + "noto sans meroitic", + "songti tc", + "andale mono", + "material icons", + "mingzat", + "droid sans", + "didot", + "geeza pro", + "mangal", + "gfs theokritos", + "gulim", + "mints mild", + "caladea", + "noto sans osage", + "noto sans tangsa", + "sniglet", + "domestic manners", + "charis sil", + "cantarell", + "noto sans deseret", + "gfs eustace", + "montserrat alternates", + "latin modern roman caps", + "gfs didot", + "spectral", + "noto sans indic siyaq numbers", + "gargi", + "lalezar", + "droid sans mono", + "georgia", + "noto sans sora sompeng", + "noto sans adlam", + "noto sans tamil", + "nu", + "noto sans mandaic", + "leland", + "gentium basic", + "kinnari", + "gfs gazis", + "kamran", + "stkaiti", + "aqui", + "arial unicode", + "cascadia code", + "kaiti", + "droid sans armenian", + "crete round", + "kartika", + "mukti", + "homa", + "khmer ui", + "anaktoria", + "gfs galatea", + "hanamin", + "latin modern roman demi", + "arshia", + "simsun", + "comicshannsmono nerd font", + "khmer os", + "latin modern roman slanted", + "kates", + "harmattan", + "ipamincho", + "shruti", + "stheiti", + "noto sans old north arabian", + "elham", + "hermit", + "simhei", + "arial unicode ms", + "ms mincho", + "tahoma", + "mukta vaani", + "amiri quran", + "leelawadee", + "inconsolatago", + "mukta malar", + "noto sans sogdian", + "noto sans mongolian", + "gill sans", + "mints strong", + "inconsolata go", + "noto sans nandinagari", + "garamond", + "noto sans canadian aboriginal", + "courier", + "noto sans nko", + "rit rachana", + "rachana", + "archivo", + "noto sans ui", + "merriweather", + "kacstpen", + "mukta mahee", + "kacstqurn", + "kacst-qr", + "kacstqura", + "cousine", + "codenewroman nerd font mono", + "kacstfarsi", + "eb garamond", + "codenewroman nerd font", + "noto sans takri", + "kacstone", + "kalinga", + "noto sans georgian", + "karla", + "manchu2005", + "ume mincho", + "kacstscreen", + "kacstart", + "andika", + "alkalami", + "kacstposter", + "noto sans thai", + "untaza", + "akkadian", + "lekton", + "tscu_paranar", + "dank mono", + "kacstletter", + "kacsttitle", + "lao ui", + "share tech mono", + "anka/coder", + "ipamonamincho", + "source sans 3", + "latin modern roman dunhill", + "noto sans hatran", + "noto sans thaana", + "mplus", + "nuosu sil", + "hasida", + "merriweather sans", + "ume mincho s3", + "silkscreen", + "undotum", + "dotum", + "noto sans armenian ui", + "noto sans cham", + "nanumgothic", + "titillium", + "quicksand", + "noto sans tai tham", + "lucida console", + "red hat mono", + "raghindi", + "gautami", + "grand hotel", + "noto sans marchen", + "arundina sans", + "gotham", + "khmer os content", + "noto sans runic", + "noto sans chorasmian", + "droid sans tamil", + "noto sans manichaean", + "noto sans kannada", + "noto sans lao ui", + "aurulentsansmono", + "uniol", + "ungraphic", + "sazanami mincho", + "noto sans kannada ui", + "noto sans old italic", + "noto sans sinhala", + "hiragino sans", + "arundina sans mono", + "noto sans multani", + "lohit assamese", + "noto sans sharada", + "noto sans caucasian albanian", + "mukta devanagari", + "noto sans tamil ui", + "inconsolatalgc", + "noto sans sinhala ui", + "noto sans mende kikakui", + "noto traditional nushu", + "jura", + "noto sans ogham", + "aurulentsansmono nerd font", + "lohit odia", + "noto sans sundanese", + "mingliu", + "lohit hindi", + "garuda", + "hadasim clm", + "inconsolatalgc nerd font", + "noto sans old sogdian", + "gfs decker", + "caladingsclm", + "nachlieli", + "lohit nepali", + "noto sans grantha", + "gfs didot classic", + "monofur", + "trade gothic", + "lohit kannada", + "shofar", + "fira mono", + "emoji one", + "ff meta", + "fira sans", + "\303\251colier court", + "droid sans georgian", + "fantezi", + "reem kufi", + "d-din condensed", + "outfit", + "kerkis", + "freemono", + "kacsttitlel", + "hiragino sans cns", + "droid sans thai", + "courier std", + "keter yg", + "gentium plus", + "ipamonagothic", + "freesans", + "artsounk", + "noto sans tagalog", + "comfortaa", + "noto sans siddham", + "ff scala", + "noto looped lao ui", + "fontawesome", + "latin modern roman unslanted", + "stam ashkenaz clm", + "farnaz", + "lohit devanagari", + "lohit tamil", + "heuristica", + "noto sans gothic", + "gfs g\303\266schen", + "noto sans old south arabian", + "darkgarden", + "asana math", + "amiri quran colored", + "3270 nerd font", + "noto sans thai looped", + "jomolhari", + "segoe ui historic", + "noto sans ugaritic", + "terminus (ttf)", + "kacstbook", + "san francisco", + "ff din", + "ferdosi", + "leelawadee ui", + "noto fangsong kss rotated", + "montserrat underline", + "noto sans nag mundari", + "noto fangsong kss vertical", + "lpfont", + "noto serif toto", + "noto serif armenian", + "minion math", + "3270 nerd font mono", + "noto sans glagolitic", + "kokila", + "fira code", + "jg laotimes", + "drift", + "lateef", + "koodak", + "sazanami gothic", + "android emoji", + "noto sans khmer", + "lohit bengali", + "noto sans georgian ui", + "noto sans kaithi", + "lisu", + "noto serif ottoman siyaq", + "space grotesk", + "noto sans math", + "figtree", + "noto sans hanunoo", + "noto sans adlam unjoined", + "noto serif lao", + "roya", + "kacstdigital", + "sparks dot large", + "noto sans thai ui", + "gfs garaldus", + "signfont", + "nachlieli clm", + "noto color emoji", + "comic neue angular", + "meiryo", + "noto sans chakma", + "source han mono", + "noto sans tirhuta", + "ms ui gothic", + "lohit konkani", + "segoe ui emoji", + "monoid nerd font", + "noto sans saurashtra", + "arimo nerd font", + "gf zemen unicode", + "lklug", + "sparks dot small", + "ungungseo", + "tinos nerd font", + "nafees nastaleeq", + "twitter color emoji", + "mononoki nerd font", + "noto sans yi", + "noto sans lisu", + "lohit kashmiri", + "inconsolata regular", + "ibm 3270 nerd font", + "lohit marathi", + "terminess nerd font", + "noto sans cherokee", + "lohit gujarati", + "lucida sans unicode", + "namdhinggo sil", + "notomono nerd font", + "gfs neohellenic", + "gfs orpheus", + "noto sans oriya", + "spark dot-line thin", + "source han sans cn", + "edwin", + "spacemono nerd font", + "noto sans myanmar", + "noto sans osmanya", + "century gothic", + "latin modern math", + "hasklig", + "jadid", + "sharetechmono nerd font", + "malayalam", + "anka/coder condensed", + "waree", + "noto serif tamil", + "noto sans ol chiki", + "noto sans myanmar ui", + "khmer os muol", + "noto looped thai ui", + "stfangsong", + "alexander", + "gfs orpheus sans", + "adwaita mono", + "meslo nerd font", + "yudit", + "source han mono sc", + "ipaex\346\230\216\346\234\235", + "nanumgothiccoding", + "terafik", + "adwaita sans", + "ume gothic o5", + "lohit sindhi", + "ume gothic s4", + "source han mono tc", + "nanumgothic_coding", + "ume gothic s5", + "fangsong ti", + "unjamosora", + "signfont z", + "ume gothic", + "futura", + "stam sefarad clm", + "noto serif dogra", + "avenir next", + "noto serif tamil slanted", + "frutiger", + "noto sans medefaidrin", + "ia writer mono", + "lohit maithili", + "gomono nerd font", + "emojione mozilla", + "noto sans newa", + "ipaex\343\202\264\343\202\267\343\203\203\343\202\257", + "news cycle", + "lucida math", + "ume gothic c4", + "ume gothic c5", + "noto sans rejang", + "oxygen mono", + "noto sans syriac eastern", + "noto sans syriac", + "sparks dot medium", + "go mono nerd font", + "spark dot-line medium", + "oxygen-sans", + "p052", + "geistmono nerd font", + "yu gothic", + "pt mono", + "sf pro", + "inconsolata nerd font", + "motoyalcedar", + "pt sans", + "luxi mono", + "plantin", + "hack", + "luxi sans", + "sampige", + "ubuntu", + "myriad pro", + "minion pro", + "noto serif georgian", + "unshinmun", + "overpass", + "sathu", + "crimson text", + "news gothic", + "noto sans lycian", + "noto serif ahom", + "noto sans mahajani", + "noto serif makasar", + "noto serif thai", + "ipaexgothic", + "fantasquesansmono", + "campania", + "prociono", + "source serif 4", + "impact", + "drugulinclm", + "fangsong", + "droidsansmono nerd font", + "tlwgmono", + "overpass mono", + "ipapmincho", + "abyssinica sil", + "perizia", + "tlwgtypo", + "droidsansm nerd font", + "jg lao old arial", + "accanthis adf std", + "kacstoffice", + "gfs jackson", + "kacstnaskh", + "ukij tuz", + "noto sans lydian", + "noto sans old turkic", + "oswald", + "fantasquesansmono nerd font", + "padmaa", + "din pro", + "noto sans elymaic", + "tlwgtypist", + "noto sans cuneiform", + "lexend", + "khmer os metal chrieng", + "noto sans malayalam", + "noto sans khmer ui", + "undinaru", + "petaluma", + "palatino", + "noto sans malayalam ui", + "old standard sfd", + "nanummyeongjo", + "kochi mincho", + "noto sans mono cjk sc", + "noto sans kharoshthi", + "gfs orpheus classic", + "noto serif kannada", + "meiryo ui", + "yudit unicode", + "noto sans mono cjk tc", + "gohu", + "noto sans cjk sc", + "source han sans kr", + "yu mincho", + "akzidenz grotesk", + "pigiarniq", + "ubuntu condensed", + "tlwgtypewriter", + "inconsolatago nerd font", + "noto sans old hungarian", + "conakry", + "noto sans cjk tc", + "hurmit nerd font", + "noto serif sinhala", + "unjamonovel", + "leland text", + "noto serif todhri", + "mgopen canonica", + "gfs porson", + "daddytimemono", + "pragmatapro", + "simple clm", + "kochi gothic", + "foundation icons", + "mgopen modata", + "tex gyre termes", + "gfs pyrsos", + "noto sans syloti nagri", + "noto sans inscriptional pahlavi", + "noto sans inscriptional parthian", + "noto sans gujarati", + "gfs fleischman", + "alef", + "rit keraleeyam", + "noto serif grantha", + "work sans", + "noto sans warang citi", + "noto sans tifinagh air", + "noto sans tifinagh adrar", + "cousine nerd font", + "noto sans tifinagh ahaggar", + "league gothic", + "noto sans tifinagh rhissa ixa", + "widelands", + "noto sans tifinagh agraw imazighen", + "malgun gothic", + "noto serif tangut", + "khmer os system", + "noto serif hentaigana", + "ms serif", + "noto sans tifinagh apt", + "freeserif", + "noto sans oriya ui", + "b612", + "opendyslexicmono", + "noto serif", + "sabon", + "infofont", + "opendyslexic", + "noto sans coptic", + "annapurna sil", + "lekton nerd font", + "symbola", + "noto sans psalter pahlavi", + "al bayan", + "unjamobatang", + "noto sans tifinagh tawellemmet", + "roboto", + "b612 mono", + "khmer mondulkiri", + "mplus nerd font", + "patrick hand", + "thonburi", + "source han mono hc", + "noto znamenny musical notation", + "noto sans mayan numerals", + "ipaexmincho", + "ms sans serif", + "tabassom", + "noto sans imperial aramaic", + "xits math", + "bitter", + "noto sans meetei mayek", + "dancing script", + "opendyslexicmono nerd font", + "hanyisong", + "albany amt", + "roboto mono", + "markazi text", + "cambria", + "unjamodotum", + "cooper std", + "noto sans gunjala gondi", + "avenir next condensed", + "itc bodoni", + "britannic", + "ume ui gothic o5", + "yu gothic ui", + "raavi", + "ume hy gothic o5", + "noto sans signwriting", + "beteckna", + "ume ui gothic", + "b compset", + "noto nastaliq urdu", + "ume hy gothic", + "noto sans tifinagh sil", + "letters laughing", + "bola", + "iosevka", + "unpen", + "badr", + "agave", + "itc stone serif", + "noto sans old persian", + "dubai", + "bodoni", + "ia writer quattro", + "vemana2000", + "agbalumo", + "noto sans cjk kr", + "unyetgul", + "noto serif khmer", + "input mono", + "fontawesome 7 free", + "noto sans wancho", + "noto sans telugu", + "gfs philostratos", + "charis sil compact", + "noto sans nabataean", + "cascadia mono pl", + "noto sans new tai lue", + "libertinus", + "iosevkaterm", + "noto sans vai", + "noto sans tifinagh ghat", + "cascadia mono nf", + "calibri", + "iosevka term", + "noto sans telugu ui", + "ia writer duo", + "elephant", + "noto sans mono cjk kr", + "pothana2000", + "infofont z", + "corbel", + "batang", + "opendyslexic nerd font", + "noto sans hanifi rohingya", + "victormono", + "gfs bodoni", + "victor mono", + "noto serif khitan small script", + "proggyclean", + "lohit malayalam", + "vazirmatn", + "red hat text", + "liberation mono", + "vrinda", + "verdana", + "noto sans arabic", + "liberation sans", + "linux libertine", + "noto sans old permic", + "unpilgia", + "inter variable", + "bellota", + "monofur nerd font", + "source han mono k", + "noto sans avestan", + "firamono nerd font", + "spark dot-line extrathin", + "gb_ss_gb18030", + "noto sans elbasan", + "droid serif", + "rockwell", + "stevehand", + "noto sans nko unjoined", + "khmer os muol light", + "linux libertine mono", + "sakkal majalla", + "tex gyre heros", + "noto sans tai viet", + "noto sans balinese", + "liberationmono nerd font", + "source han serif cn", + "urdu nastaliq unicode", + "noto serif oriya", + "emoji two", + "ubuntu nerd font", + "cumberland amt", + "digna's handwriting", + "new athena unicode", + "firacode nerd font", + "firacode nerd font mono", + "noto sans phoenician", + "motoyalmaru", + "noto serif myanmar", + "gohu nerd font", + "spark dot-line thick", + "tex gyre cursor", + "vl gothic", + "noto sans zanabazar square", + "cumberland", + "noto sans gujarati ui", + "noto sans lao looped", + "unifrakturmaguntia", + "cascadia code pl", + "ubuntumono nerd font", + "cascadia code nf", + "noto sans tifinagh", + "tex gyre heros cn", + "noto sans tifinagh azawagh", + "noto sans ethiopic", + "proggysquarettsz", + "delphine", + "franklin gothic", + "unbom", + "noto sans gurmukhi", + "apparatus sil", + "tai heritage pro", + "noto sans lepcha", + "tajawal", + "noto sans tamil supplement", + "khmer os fasthand", + "khmer os freehand", + "ipapgothic", + "noto sans bengali", + "hasklug nerd font", + "andika compact", + "dai banna sil", + "nimbus mono", + "pcfont", + "profont", + "nimbus roman", + "source code pro", + "nimbus sans", + "noto sans bengali ui", + "bauer bodoni", + "tex gyre schola", + "itc bookman", + "fixedsys", + "stix two math", + "david clm", + "noto sans khojki", + "lohit telugu", + "vazirmatn nl", + "traditional arabic", + "noto sans kayah li", + "trebuchet ms", + "noto sans bamum", + "univers", + "vazirmatn rd", + "noto sans tifinagh hawad", + "noto sans brahmi", + "sparks dot extrasmall", + "zapfino", + "yehudaclm", + "gillius adf", + "ethiopic washra", + "noto serif yezidi", + "ar pl new sung mono", + "noto sans devanagari", + "unpenheulim", + "noto sans devanagari ui", + "arundina serif", + "baskerville", + "fixed", + "droid sans ethiopic", + "sf pro rounded", + "sparks dot extralarge", + "roboto condensed", + "noto serif malayalam", + "noto sans mono cjk hk", + "noto sans arabic ui", + "keyfont v2", + "gfs bodoni classic", + "bpg utf8 m", + "saysettha unicode", + "padauk", + "navilu", + "noto naskh arabic ui", + "source han serif kr", + "noto serif cjk sc", + "unvada", + "noto sans shavian", + "pcfont z", + "ume p mincho", + "noto serif cjk tc", + "spark dot-line extrathick", + "stix", + "gentium plus compact", + "noto naskh arabic", + "vazirmatn ui", + "raleway", + "vazirmatn rd nl", + "apple color emoji", + "noto serif gujarati", + "ar pl new sung", + "inconsolata bold", + "ume p mincho s3", + "ume p gothic o5", + "ume p gothic s4", + "haettenschweiler", + "ume p gothic s5", + "krungthep", + "entypo", + "ume p gothic", + "pmingliu", + "brandon grotesque", + "frank ruehl", + "linux biolinum", + "urw gothic", + "helvetica", + "ar pl zenkai uni", + "nimbus mono l", + "lohit gurmukhi", + "noto sans pau cin hau", + "nimbus sans l", + "vollkorn", + "ume p gothic c4", + "ume p gothic c5", + "rit meera new", + "kacstdecorative", + "overpass nerd font", + "antykwatorunska", + "noto sans syriac western", + "noto sans ethiopic ui", + "microsoft yahei", + "tex gyre chorus", + "noto sans buginese", + "rubik", + "apple sd gothic neo", + "nimbus roman no9 l", + "im writing nerd font mono", + "biaukai", + "im writing nerd font", + "unbatang", + "stix two text", + "jetbrains mono", + "droid sans devanagari", + "antykwatorunska medium", + "frank ruehl clm", + "gentium book basic", + "armnet helvetica", + "droid sans japanese", + "vazirmatn rd ui", + "lilex nerd font", + "noto sans gurmukhi ui", + "arial hebrew", + "gfs complutum", + "tobecontinued", + "baekmuk batang", + "gelly", + "ibmplexmono nerd font", + "ibm plex mono", + "cordia new", + "book antiqua", + "khmer os bokor", + "umeplus gothic", + "antykwatorunskacond medium", + "ibm plex sans", + "aegyptus", + "goudy bookletter 1911", + "khmer os muol pali", + "antykwatorunskacond light", + "noto sans cypro minoan", + "daddytimemono nerd font", + "sf pro text", + "noto sans cypriot", + "noto sans batak", + "new peninim mt", + "baekmuk dotum", + "noto serif cjk kr", + "hiragino mincho pron", + "noto serif telugu", + "snap", + "fontawesome 7 brands", + "noto serif tibetan", + "lilex", + "umpush", + "perpetua", + "noto sans cjk hk", + "vazirmatn ui nl", + "pingfang sc", + "noto sans palmyrene", + "cambria math", + "hoefler text", + "pingfang tc", + "albany", + "noto kufi arabic", + "antykwatorunskacond", + "lucidatypewriter", + "noto sans javanese", + "dejavu sans", + "baekmuk gulim", + "lucida bright", + "anonymicepro nerd font mono", + "anonymicepro nerd font", + "petalumatext", + "noto serif balinese", + "biz udmincho", + "openmoji black", + "tagmukay", + "biz udpmincho", + "noto sans limbu", + "dejavu sans mono", + "sparks bar medium", + "d-din exp", + "umeplus p gothic", + "robotomono nerd font", + "noto serif ethiopic", + "bpg glaho international", + "biz udgothic", + "twentieth century", + "glisp", + "mukti narrow", + "agave nerd font", + "noto sans soyombo", + "vazirmatn rd ui nl", + "dejavusansmono nerd font", + "hiragino kaku gothic", + "iosevka nerd font", + "anonymous pro", + "bauhaus std", + "agave nerd font mono", + "microsoft jhenghei", + "iosevka nerd font mono", + "noto serif gurmukhi", + "envycoder", + "iosevkaterm nerd font", + "courier new", + "itc zapf chancery std", + "noto serif np hmong", + "noto sans khudawadi", + "vdrsymbols sans", + "noto serif bengali", + "noto sans buhid", + "applemyungjo", + "luxi serif", + "rit tn joy", + "pt serif", + "microsoft yahei ui", + "barlow", + "proggyclean nerd font", + "sourcecodepro nerd font", + "petalumascript", + "helvetica neue", + "victormono nerd font", + "helvetica lt std", + "petaluma script", + "youyuan", + "noto sans symbols", + "noto serif khojki", + "noto sans symbols 2", + "ar pl uming hk", + "anka/coder narrow", + "biz udpgothic", + "noto serif devanagari", + "new york", + "proggytinyttsz", + "source han serif tw", + "antykwatorunska light", + "liberation sans narrow", + "public sans", + "noto sans tagbanwa", + "laconic-shadow", + "adobe caslon pro", + "noto sans egyptian hieroglyphs", + "ar pl ukai hk", + "khmer os siemreap", + "noto sans vithkuqi", + "profont nerd font", + "noto sans duployan", + "adobe garamond pro", + "beteckna lower case", + "segoe ui symbol", + "saab", + "heavydata", + "tribun adf std", + "goudy old style", + "libre caslon text", + "joypixels", + "tex gyre pagella", + "wenquanyi micro hei", + "microsoft jhenghei ui", + "wenquanyi micro hei mono", + "wenquanyi zen hei", + "noto serif old uyghur", + "paktype tehreer", + "ar pl shanheisun uni", + "fkp", + "caskaydiacove nerd font mono", + "caskaydiacove nerd font", + "noto sans phags pa", + "yanone kaffeesatz", + "droid arabic naskh", + "tex gyre adventor", + "source han sans tw", + "sophia nubian", + "gubbi", + "noto serif cjk hk", + "simplified arabic", + "sparks bar wide", + "nimbus mono ps", + "liberation serif", + "gb_ss_gb18030_extended", + "silkscreen expanded", + "noto sans mono cjk jp", + "noto sans bhaiksuki", + "lohit punjabi", + "beteckna small caps", + "scheherazade new", + "b davat", + "jetbrainsmono nerd font", + "arabic typesetting", + "tex gyre bonum", + "noto sans linear b", + "bitstream vera sans", + "bitstream vera sans mono", + "andika new basic", + "droid sans fallback", + "bitstreamverasansmono nerd font", + "pt serif caption", + "inter display", + "urw bookman", + "tuffy", + "zilla slab highlight", + "droid arabic kufi", + "ar pl mingti2l big5", + "paktype naqsh", + "gb_ss_gb18030_extendedk", + "dejavusansm nerd font", + "zilla slab", + "pingfang hk", + "bravura", + "noto sans display", + "vl pgothic", + "noto sans hebrew ui", + "copperplate gothic std", + "poppins", + "bigblueterminal", + "envycoder nerd font", + "source han serif jp", + "noto sans bassa vah", + "noto serif vithkuqi", + "bigblueterminal nerd font", + "khmer os battambang", + "ar pl uming tw", + "palatino linotype", + "source code vf", + "ibm plex serif", + "noto sans pahawh hmong", + "hiragino sans gb", + "red hat display", + "ektype baloo 2", + "bonvenocf", + "ar pl ukai tw", + "proxima nova", + "dejavu serif", + "ektype baloo tamma 2", + "heavydata nerd font", + "libre baskerville", + "gfs baskerville", + "padauk book", + "ektype baloo da 2", + "source han sans jp", + "sparks bar narrow", + "noto sans hebrew", + "sparks bar extranarrow", + "noto rashi hebrew", + "sparks bar extrawide", + "unikurd web", + "noto serif display", + "hapax berb\303\250re", + "source han code jp", + "be vietnam pro", + "noto sans cjk jp", + "droid sans hebrew", + "ektype baloo chettan 2", + "roboto slab", + "sf pro display", + "bravuratext", + "finale broadway text", + "wenquanyi zen hei sharp", + "bitstream vera serif", + "ektype baloo tammudu 2", + "noto serif hebrew", + "paktype naskh basic wide", + "paktype naskh basic semi wide", + "paktype naskh basic", + "noto serif cjk jp", + "ar pl sungtil gb", + "wenquanyi bitmap song", + "finale broadway", + "m yuppy gb", + "ektype baloo bhai 2", + "ektype baloo bhaina 2", + "ektype baloo paaji 2", + "ektype baloo thambi 2", + "playfair display" + }; +#define FcConstFamilyNamePool ((const char *) &FcConstFamilyNamePool_contents) +const struct FcGenericFamilyEntry * +fc_generic_family_lookup (register const char *str, register size_t len) +{ +#if (defined __GNUC__ && __GNUC__ + (__GNUC_MINOR__ >= 6) > 4) || (defined __clang__ && __clang_major__ >= 3) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + static const struct FcGenericFamilyEntry wordlist[] = + { + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 1049 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str93, 0x00000002}, + {-1}, +#line 1057 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str95, 0x00000002}, + {-1}, {-1}, {-1}, +#line 53 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str99, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 994 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str105, 0x00000002}, + {-1}, +#line 108 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str107, 0x00000001}, +#line 101 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str108, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 675 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str113, 0x00000001}, + {-1}, +#line 98 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str115, 0x00000002}, + {-1}, {-1}, +#line 928 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str118, 0x00000004}, + {-1}, +#line 581 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str120, 0x00000004}, + {-1}, {-1}, {-1}, +#line 659 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str124, 0x00000002}, +#line 112 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str125, 0x00000002}, + {-1}, +#line 580 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str127, 0x00000004}, + {-1}, +#line 626 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str129, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 592 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str134, 0x00000006}, +#line 1029 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str135, 0x00000004}, +#line 930 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str136, 0x00000002}, +#line 589 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str137, 0x00000002}, + {-1}, {-1}, +#line 582 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str140, 0x00000004}, + {-1}, {-1}, {-1}, +#line 617 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str144, 0x00000001}, + {-1}, +#line 942 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str146, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1135 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str150, 0x00000001}, + {-1}, {-1}, {-1}, +#line 70 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str154, 0x00000002}, +#line 674 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str155, 0x00000020}, +#line 409 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str156, 0x00000004}, + {-1}, {-1}, +#line 431 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str159, 0x00000002}, +#line 284 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str160, 0x00000002}, +#line 1132 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str161, 0x00000001}, + {-1}, {-1}, {-1}, +#line 1037 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str165, 0x00000002}, + {-1}, +#line 934 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str167, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 610 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str172, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 689 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str177, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 615 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str185, 0x00000004}, + {-1}, +#line 1116 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str187, 0x00000004}, +#line 678 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str188, 0x00000400}, +#line 1130 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str189, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 1051 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str194, 0x00000002}, + {-1}, +#line 156 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str196, 0x00000001}, + {-1}, +#line 1246 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str198, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 635 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str208, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 648 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str215, 0x00000002}, + {-1}, {-1}, +#line 157 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str218, 0x00000002}, + {-1}, {-1}, {-1}, +#line 620 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str222, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 931 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str229, 0x00000002}, +#line 649 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str230, 0x00000001}, + {-1}, {-1}, +#line 182 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str233, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 215 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str239, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1240 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str243, 0x00000001}, + {-1}, {-1}, +#line 611 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str246, 0x00000004}, + {-1}, {-1}, +#line 180 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str249, 0x00000001}, + {-1}, +#line 198 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str251, 0x00000004}, +#line 941 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str252, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 181 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str262, 0x00000001}, + {-1}, +#line 628 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str264, 0x00000002}, + {-1}, {-1}, +#line 794 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str267, 0x00000002}, + {-1}, {-1}, {-1}, +#line 197 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str271, 0x00000004}, +#line 1238 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str272, 0x00000001}, +#line 1079 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str273, 0x00000004}, +#line 42 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str274, 0x00000002}, +#line 614 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str275, 0x00000002}, + {-1}, {-1}, +#line 204 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str278, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 785 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str286, 0x00000002}, + {-1}, {-1}, +#line 788 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str289, 0x00000004}, +#line 1245 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str290, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1136 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str297, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, +#line 1078 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str302, 0x00000004}, + {-1}, +#line 183 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str304, 0x00000002}, + {-1}, +#line 211 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str306, 0x00000001}, + {-1}, +#line 261 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str308, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 568 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str313, 0x00000001}, + {-1}, +#line 647 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str315, 0x00000002}, + {-1}, {-1}, {-1}, +#line 567 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str319, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 195 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str330, 0x00000002}, +#line 256 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str331, 0x00000001}, + {-1}, {-1}, +#line 199 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str334, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 595 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str344, 0x00000004}, + {-1}, {-1}, {-1}, +#line 111 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str348, 0x00000001}, + {-1}, {-1}, +#line 583 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str351, 0x00000002}, +#line 522 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str352, 0x00000002}, + {-1}, {-1}, +#line 623 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str355, 0x00000004}, + {-1}, +#line 598 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str357, 0x00000004}, + {-1}, {-1}, {-1}, +#line 1131 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str361, 0x00000001}, + {-1}, {-1}, +#line 625 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str364, 0x00000004}, +#line 542 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str365, 0x00000002}, +#line 584 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str366, 0x00000002}, + {-1}, {-1}, +#line 1035 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str369, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 618 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str377, 0x00000010}, +#line 236 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str378, 0x00000002}, + {-1}, +#line 57 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str380, 0x00000010}, +#line 694 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str381, 0x00000002}, +#line 1243 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str382, 0x00000005}, + {-1}, {-1}, +#line 569 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str385, 0x00000001}, +#line 1050 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str386, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, +#line 453 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str391, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 676 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str406, 0x00000004}, +#line 827 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str407, 0x00000002}, + {-1}, +#line 619 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str409, 0x00000002}, + {-1}, {-1}, {-1}, +#line 547 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str413, 0x00000001}, +#line 778 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str414, 0x00000002}, +#line 1128 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str415, 0x00000001}, + {-1}, {-1}, +#line 684 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str418, 0x00000800}, + {-1}, +#line 259 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str420, 0x00000003}, +#line 708 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str421, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 282 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str427, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 234 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str439, 0x00000002}, + {-1}, +#line 190 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str441, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 167 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str446, 0x00000002}, + {-1}, {-1}, {-1}, +#line 450 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str450, 0x00000008}, + {-1}, {-1}, {-1}, {-1}, +#line 171 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str455, 0x00000004}, +#line 176 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str456, 0x00000001}, +#line 369 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str457, 0x00000004}, +#line 164 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str458, 0x00000002}, + {-1}, +#line 36 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str460, 0x00000010}, + {-1}, +#line 1106 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str462, 0x00000001}, + {-1}, +#line 166 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str464, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 1148 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str469, 0x00000002}, + {-1}, +#line 1047 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str471, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 192 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str479, 0x00000008}, +#line 357 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str480, 0x00000010}, + {-1}, {-1}, {-1}, +#line 49 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str484, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 762 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str490, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1025 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str494, 0x00000022}, + {-1}, {-1}, {-1}, {-1}, +#line 193 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str499, 0x00000004}, + {-1}, {-1}, +#line 115 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str502, 0x00000001}, + {-1}, {-1}, {-1}, +#line 262 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str506, 0x00000002}, + {-1}, +#line 661 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str508, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 328 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str513, 0x00000002}, +#line 185 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str514, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 275 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str519, 0x00000002}, + {-1}, {-1}, +#line 353 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str522, 0x00000010}, + {-1}, {-1}, +#line 786 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str525, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 430 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str533, 0x00000004}, +#line 329 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str534, 0x00000004}, + {-1}, +#line 184 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str536, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 418 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str541, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 338 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str550, 0x00000010}, + {-1}, {-1}, +#line 1129 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str553, 0x00000001}, + {-1}, +#line 510 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str555, 0x00000002}, + {-1}, {-1}, {-1}, +#line 364 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str559, 0x00000010}, + {-1}, +#line 94 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str561, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 186 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str568, 0x00000004}, + {-1}, +#line 444 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str570, 0x00000006}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 636 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str583, 0x00000006}, + {-1}, {-1}, {-1}, +#line 216 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str587, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 339 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str592, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 50 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str600, 0x00000002}, + {-1}, {-1}, +#line 378 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str603, 0x00000008}, + {-1}, {-1}, +#line 940 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str606, 0x00000400}, + {-1}, {-1}, {-1}, +#line 516 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str610, 0x00000001}, +#line 356 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str611, 0x00000010}, + {-1}, +#line 767 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str613, 0x00000002}, +#line 285 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str614, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 616 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str621, 0x00000004}, + {-1}, +#line 1114 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str623, 0x00000004}, +#line 1054 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str624, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 847 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str629, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 784 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str639, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1055 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str646, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 58 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str654, 0x00000004}, +#line 591 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str655, 0x00000010}, + {-1}, +#line 607 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str657, 0x00000002}, + {-1}, {-1}, {-1}, +#line 242 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str661, 0x00000002}, +#line 232 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str662, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 327 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str668, 0x00000002}, + {-1}, {-1}, {-1}, +#line 588 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str672, 0x00000002}, + {-1}, {-1}, +#line 365 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str675, 0x00000010}, + {-1}, +#line 380 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str677, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 612 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str684, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 158 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str689, 0x00000001}, +#line 817 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str690, 0x00000002}, + {-1}, {-1}, +#line 854 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str693, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1053 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str711, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, +#line 237 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str716, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 178 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str726, 0x00000001}, +#line 165 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str727, 0x00000020}, + {-1}, +#line 723 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str729, 0x00000002}, + {-1}, +#line 347 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str731, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 629 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str744, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 517 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str757, 0x00000001}, +#line 345 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str758, 0x00000001}, + {-1}, {-1}, {-1}, +#line 1096 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str762, 0x00000001}, +#line 749 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str763, 0x00000002}, + {-1}, {-1}, {-1}, +#line 321 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str767, 0x00000002}, +#line 512 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str768, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 250 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str773, 0x00000004}, + {-1}, {-1}, +#line 336 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str776, 0x00000001}, + {-1}, {-1}, +#line 836 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str779, 0x00000002}, + {-1}, {-1}, +#line 690 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str782, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 851 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str792, 0x00000002}, + {-1}, {-1}, {-1}, +#line 929 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str796, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 775 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str803, 0x00000002}, + {-1}, {-1}, +#line 528 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str806, 0x00000010}, +#line 332 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str807, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 504 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str814, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 351 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str820, 0x00000010}, + {-1}, {-1}, +#line 483 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str823, 0x00000010}, + {-1}, {-1}, {-1}, +#line 1105 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str827, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 81 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str836, 0x00000002}, + {-1}, {-1}, {-1}, +#line 96 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str840, 0x00000002}, + {-1}, {-1}, {-1}, +#line 168 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str844, 0x00000004}, +#line 481 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str845, 0x00000001}, + {-1}, +#line 243 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str847, 0x00000002}, +#line 210 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str848, 0x00000001}, + {-1}, {-1}, +#line 485 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str851, 0x00000002}, + {-1}, +#line 645 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str853, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 404 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str858, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 503 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str866, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 56 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str873, 0x00000001}, + {-1}, {-1}, +#line 349 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str876, 0x00000001}, +#line 384 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str877, 0x00000001}, + {-1}, +#line 518 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str879, 0x00000001}, + {-1}, {-1}, {-1}, +#line 102 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str883, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 1048 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str888, 0x00000001}, +#line 194 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str889, 0x00000004}, + {-1}, {-1}, +#line 491 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str892, 0x00000003}, + {-1}, {-1}, +#line 520 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str895, 0x00000001}, +#line 486 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str896, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 387 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str901, 0x00000002}, +#line 445 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str902, 0x00000001}, + {-1}, +#line 1039 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str904, 0x00000002}, +#line 1101 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str905, 0x00000002}, + {-1}, +#line 809 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str907, 0x00000002}, +#line 274 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str908, 0x00000002}, + {-1}, {-1}, +#line 396 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str911, 0x00000004}, +#line 1044 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str912, 0x00000002}, +#line 97 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str913, 0x00000002}, + {-1}, +#line 637 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str915, 0x00000001}, +#line 1110 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str916, 0x00000002}, +#line 644 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str917, 0x00000001}, + {-1}, +#line 54 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str919, 0x00000001}, + {-1}, +#line 524 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str921, 0x00000002}, +#line 423 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str922, 0x00000004}, +#line 643 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str923, 0x00000001}, +#line 835 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str924, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 787 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str929, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 366 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str934, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 613 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str940, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 420 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str948, 0x00000004}, + {-1}, +#line 800 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str950, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 320 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str955, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 707 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str967, 0x00000002}, + {-1}, {-1}, +#line 205 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str970, 0x00000004}, + {-1}, +#line 803 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str972, 0x00000002}, + {-1}, {-1}, +#line 1005 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str975, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 996 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str984, 0x00000001}, +#line 93 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str985, 0x00000002}, +#line 875 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str986, 0x00000020}, +#line 596 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str987, 0x00000001}, + {-1}, {-1}, +#line 474 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str990, 0x00000002}, + {-1}, +#line 642 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str992, 0x00000001}, +#line 477 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str993, 0x00000002}, +#line 464 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str994, 0x00000003}, +#line 476 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str995, 0x00000003}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 208 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1004, 0x00000004}, + {-1}, +#line 188 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1006, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 469 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1012, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 260 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1024, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 187 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1031, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 850 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1039, 0x00000002}, +#line 473 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1040, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 482 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1045, 0x00000002}, +#line 733 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1046, 0x00000002}, +#line 484 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1047, 0x00000002}, + {-1}, {-1}, {-1}, +#line 587 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1051, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1164 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1055, 0x00000001}, +#line 478 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1056, 0x00000002}, + {-1}, {-1}, {-1}, +#line 465 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1060, 0x00000001}, +#line 59 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1061, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 52 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1066, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 475 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1071, 0x00000002}, + {-1}, +#line 858 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1073, 0x00000002}, + {-1}, +#line 1197 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1075, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 43 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1081, 0x00000010}, +#line 526 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1082, 0x00000004}, + {-1}, {-1}, {-1}, +#line 1146 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1086, 0x00000002}, + {-1}, {-1}, {-1}, +#line 223 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1090, 0x00000004}, + {-1}, {-1}, +#line 470 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1093, 0x00000002}, + {-1}, +#line 479 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1095, 0x00000002}, + {-1}, +#line 513 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1097, 0x00000020}, +#line 1034 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1098, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 63 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1105, 0x00000004}, + {-1}, +#line 447 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1107, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 1074 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1112, 0x00000002}, +#line 519 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1113, 0x00000001}, + {-1}, +#line 745 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1115, 0x00000002}, + {-1}, +#line 857 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1117, 0x00000002}, +#line 633 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1118, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 932 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1124, 0x00000002}, + {-1}, {-1}, +#line 388 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1127, 0x00000004}, +#line 597 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1128, 0x00000002}, +#line 1165 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1129, 0x00000001}, + {-1}, {-1}, {-1}, +#line 1042 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1133, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1182 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1149, 0x00000002}, +#line 238 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1150, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 695 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1160, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, +#line 711 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1165, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 655 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1178, 0x00000006}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1134 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1184, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 993 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1193, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 848 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1209, 0x00000002}, +#line 572 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1210, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 1000 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1221, 0x00000004}, + {-1}, +#line 997 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1223, 0x00000003}, + {-1}, {-1}, {-1}, +#line 323 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1227, 0x00000002}, + {-1}, {-1}, +#line 377 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1230, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 777 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1241, 0x00000002}, +#line 104 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1242, 0x00000002}, + {-1}, {-1}, {-1}, +#line 374 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1246, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 494 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1259, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 826 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1267, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 713 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1273, 0x00000002}, + {-1}, {-1}, +#line 251 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1276, 0x00000002}, + {-1}, {-1}, {-1}, +#line 776 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1280, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 754 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1292, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 764 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1307, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 109 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1316, 0x00000004}, + {-1}, {-1}, {-1}, +#line 1187 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1320, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 1183 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1325, 0x00000002}, + {-1}, +#line 1023 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1327, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 755 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1336, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, +#line 808 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1341, 0x00000002}, + {-1}, +#line 833 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1343, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 400 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1348, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 105 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1354, 0x00000004}, + {-1}, {-1}, +#line 795 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1357, 0x00000002}, + {-1}, +#line 549 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1359, 0x00000002}, + {-1}, {-1}, +#line 829 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1362, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 709 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1376, 0x00000002}, + {-1}, +#line 641 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1378, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 853 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1383, 0x00000020}, +#line 425 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1384, 0x00000004}, + {-1}, {-1}, +#line 834 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1387, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 783 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1393, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 925 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1410, 0x00000008}, +#line 463 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1411, 0x00000002}, + {-1}, +#line 805 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1413, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 110 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1419, 0x00000004}, + {-1}, {-1}, +#line 562 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1422, 0x00000007}, + {-1}, {-1}, +#line 838 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1425, 0x00000002}, + {-1}, {-1}, {-1}, +#line 606 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1429, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 554 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1437, 0x00000007}, + {-1}, +#line 322 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1439, 0x00000002}, +#line 382 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1440, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 426 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1449, 0x00000004}, + {-1}, {-1}, {-1}, +#line 812 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1453, 0x00000002}, + {-1}, {-1}, +#line 344 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1456, 0x00000002}, +#line 159 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1457, 0x00000010}, + {-1}, {-1}, +#line 651 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1460, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 561 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1468, 0x00000007}, + {-1}, {-1}, +#line 737 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1471, 0x00000002}, + {-1}, {-1}, +#line 346 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1474, 0x00000001}, + {-1}, {-1}, {-1}, +#line 621 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1478, 0x00000004}, +#line 1142 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1479, 0x00000002}, + {-1}, {-1}, {-1}, +#line 555 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1483, 0x00000007}, +#line 1038 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1484, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 300 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1499, 0x00000004}, + {-1}, +#line 276 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1501, 0x00000400}, + {-1}, {-1}, {-1}, +#line 294 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1505, 0x00000002}, + {-1}, +#line 301 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1507, 0x00000002}, +#line 1244 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1508, 0x00000008}, + {-1}, {-1}, {-1}, +#line 247 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1512, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 290 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1523, 0x00000010}, + {-1}, +#line 1002 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1525, 0x00000002}, + {-1}, {-1}, {-1}, +#line 217 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1529, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 944 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1537, 0x00000002}, + {-1}, {-1}, {-1}, +#line 487 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1541, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 315 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1550, 0x00000004}, +#line 480 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1551, 0x00000002}, + {-1}, {-1}, {-1}, +#line 401 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1555, 0x00000002}, + {-1}, +#line 252 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1557, 0x00000002}, + {-1}, {-1}, +#line 207 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1560, 0x00000004}, + {-1}, {-1}, +#line 488 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1563, 0x00000002}, + {-1}, {-1}, +#line 334 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1566, 0x00000001}, + {-1}, {-1}, {-1}, +#line 446 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1570, 0x00000006}, +#line 316 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1571, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 103 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1601, 0x00000003}, + {-1}, +#line 845 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1603, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 189 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1611, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 831 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1616, 0x00000002}, +#line 295 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1617, 0x00000001}, + {-1}, {-1}, {-1}, +#line 682 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1621, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 308 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1629, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 521 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1642, 0x00000001}, +#line 1097 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1643, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 291 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1648, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 551 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1654, 0x00000006}, +#line 565 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1655, 0x00000007}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 397 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1670, 0x00000001}, +#line 736 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1671, 0x00000002}, +#line 352 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1672, 0x00000001}, + {-1}, {-1}, {-1}, +#line 813 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1676, 0x00000002}, + {-1}, {-1}, {-1}, +#line 224 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1680, 0x00000002}, + {-1}, {-1}, {-1}, +#line 107 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1684, 0x00000801}, +#line 55 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1685, 0x00000001}, +#line 28 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1686, 0x00000004}, + {-1}, {-1}, +#line 859 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1689, 0x00000002}, + {-1}, {-1}, +#line 461 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1692, 0x00000001}, + {-1}, +#line 1027 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1694, 0x00000020}, + {-1}, +#line 874 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1696, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1117 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1706, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 466 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1711, 0x00000002}, + {-1}, +#line 1019 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1713, 0x00000002}, + {-1}, +#line 293 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1715, 0x00000002}, +#line 292 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1716, 0x00000001}, + {-1}, +#line 525 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1718, 0x00000020}, +#line 679 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1719, 0x00001000}, +#line 630 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1720, 0x00000002}, +#line 799 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1721, 0x00000002}, + {-1}, {-1}, {-1}, +#line 680 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1725, 0x00001000}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 570 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1733, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 922 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1738, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 884 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1750, 0x00000001}, +#line 608 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1751, 0x00000800}, + {-1}, +#line 29 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1753, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 735 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1758, 0x00000002}, +#line 507 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1759, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 299 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1765, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 460 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1775, 0x00000001}, + {-1}, +#line 239 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1777, 0x00000002}, +#line 514 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1778, 0x00000001}, +#line 508 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1779, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1022 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1795, 0x00000002}, + {-1}, +#line 62 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1797, 0x00000400}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 758 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1807, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 550 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1822, 0x00000007}, + {-1}, {-1}, +#line 734 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1825, 0x00000020}, +#line 753 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1826, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 546 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1836, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 913 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1841, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1077 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1849, 0x00000002}, + {-1}, +#line 779 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1851, 0x00000800}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 296 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1860, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 744 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1868, 0x00000002}, + {-1}, {-1}, +#line 691 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1871, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 906 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1877, 0x00000001}, + {-1}, +#line 1013 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1879, 0x00000002}, + {-1}, {-1}, +#line 468 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1882, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1093 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1890, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 860 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1895, 0x00000020}, +#line 350 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1896, 0x00000010}, + {-1}, {-1}, {-1}, +#line 1040 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1900, 0x00000002}, +#line 652 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1901, 0x00000002}, + {-1}, {-1}, +#line 677 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1904, 0x00000400}, + {-1}, {-1}, +#line 191 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1907, 0x00000002}, +#line 593 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1908, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 710 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1914, 0x00000002}, +#line 1061 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1915, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 873 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1927, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 640 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1944, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 557 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1951, 0x00000007}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1026 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1957, 0x00000400}, + {-1}, +#line 624 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1959, 0x00000004}, + {-1}, +#line 828 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1961, 0x00000002}, + {-1}, {-1}, {-1}, +#line 99 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1965, 0x00000004}, + {-1}, {-1}, {-1}, +#line 337 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1969, 0x00000006}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 548 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1985, 0x00000007}, +#line 1095 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1986, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 1184 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str1998, 0x00000008}, + {-1}, {-1}, {-1}, {-1}, +#line 1133 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2003, 0x00000005}, + {-1}, +#line 653 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2005, 0x00000008}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 1150 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2018, 0x00000400}, + {-1}, {-1}, {-1}, +#line 627 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2022, 0x00000004}, + {-1}, {-1}, +#line 880 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2025, 0x00000002}, +#line 769 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2026, 0x00000002}, + {-1}, {-1}, {-1}, +#line 556 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2030, 0x00000007}, + {-1}, {-1}, {-1}, {-1}, +#line 422 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2035, 0x00000004}, + {-1}, +#line 410 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2037, 0x00000004}, +#line 560 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2038, 0x00000007}, + {-1}, +#line 1115 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2040, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 712 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2045, 0x00000002}, + {-1}, +#line 552 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2047, 0x00000007}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 574 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2055, 0x00000002}, + {-1}, {-1}, +#line 654 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2058, 0x00000001}, + {-1}, {-1}, {-1}, +#line 927 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2062, 0x00000004}, + {-1}, {-1}, +#line 355 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2065, 0x00000002}, + {-1}, {-1}, {-1}, +#line 358 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2069, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 815 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2093, 0x00000002}, +#line 1085 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2094, 0x00000002}, +#line 1066 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2095, 0x00000006}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 263 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2126, 0x00000003}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1080 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2133, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 796 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2144, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 818 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2152, 0x00000002}, + {-1}, {-1}, +#line 177 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2155, 0x00000002}, + {-1}, {-1}, {-1}, +#line 515 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2159, 0x00000800}, + {-1}, +#line 389 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2161, 0x00000004}, +#line 456 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2162, 0x00000001}, +#line 1036 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2163, 0x00000004}, + {-1}, +#line 585 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2165, 0x00000003}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 64 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2174, 0x00000004}, + {-1}, {-1}, {-1}, +#line 1221 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2178, 0x00000002}, +#line 915 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2179, 0x00000001}, + {-1}, +#line 806 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2181, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 797 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2188, 0x00000020}, +#line 498 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2189, 0x00000004}, + {-1}, +#line 683 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2191, 0x00000020}, +#line 1100 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2192, 0x00001000}, + {-1}, {-1}, {-1}, {-1}, +#line 51 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2197, 0x00000001}, + {-1}, +#line 360 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2199, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 34 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2206, 0x00000004}, +#line 599 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2207, 0x00000004}, +#line 1236 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2208, 0x00000002}, +#line 1064 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2209, 0x00000004}, +#line 443 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2210, 0x00000001}, + {-1}, {-1}, +#line 657 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2213, 0x00000004}, + {-1}, {-1}, {-1}, +#line 1113 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2217, 0x00000002}, + {-1}, +#line 35 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2219, 0x00000022}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1159 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2225, 0x00000002}, +#line 564 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2226, 0x00000007}, + {-1}, {-1}, +#line 1160 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2229, 0x00000002}, + {-1}, +#line 1065 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2231, 0x00000004}, +#line 656 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2232, 0x00000004}, +#line 1161 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2233, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 287 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2239, 0x00000004}, + {-1}, {-1}, +#line 1192 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2242, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1041 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2249, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1156 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2253, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 319 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2259, 0x00000002}, + {-1}, +#line 1098 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2261, 0x00000001}, + {-1}, {-1}, +#line 894 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2264, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 113 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2276, 0x00000002}, + {-1}, +#line 916 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2278, 0x00000001}, +#line 318 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2279, 0x00000002}, + {-1}, +#line 781 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2281, 0x00000002}, +#line 407 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2282, 0x00000004}, + {-1}, {-1}, {-1}, +#line 558 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2286, 0x00000007}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 373 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2294, 0x00000004}, +#line 278 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2295, 0x00000400}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 802 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2301, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 442 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2320, 0x00000002}, + {-1}, {-1}, +#line 665 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2323, 0x00000002}, + {-1}, {-1}, +#line 573 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2326, 0x00000800}, +#line 1157 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2327, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1158 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2331, 0x00000002}, +#line 825 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2332, 0x00000002}, + {-1}, {-1}, +#line 948 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2335, 0x00000004}, +#line 843 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2336, 0x00000002}, + {-1}, {-1}, {-1}, +#line 842 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2340, 0x00000002}, + {-1}, +#line 1094 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2342, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 370 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2352, 0x00000004}, + {-1}, +#line 1083 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2354, 0x00000002}, + {-1}, +#line 949 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2356, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 950 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2362, 0x00000001}, + {-1}, {-1}, +#line 330 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2365, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1233 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2372, 0x00000002}, +#line 988 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2373, 0x00000004}, +#line 1030 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2374, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 421 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2381, 0x00000004}, +#line 631 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2382, 0x00000004}, +#line 989 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2383, 0x00000002}, +#line 576 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2384, 0x00000004}, +#line 974 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2385, 0x00000001}, + {-1}, +#line 381 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2387, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 577 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2392, 0x00000002}, + {-1}, +#line 1018 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2394, 0x00000003}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 1151 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2405, 0x00000002}, + {-1}, {-1}, {-1}, +#line 650 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2409, 0x00000002}, +#line 609 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2410, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 896 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2415, 0x00000001}, +#line 1196 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2416, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 945 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2425, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1020 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2429, 0x00000002}, + {-1}, {-1}, +#line 212 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2432, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 666 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2438, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 770 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2445, 0x00000002}, +#line 883 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2446, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 772 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2455, 0x00000002}, +#line 907 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2456, 0x00000001}, + {-1}, {-1}, {-1}, +#line 919 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2460, 0x00000001}, + {-1}, {-1}, +#line 440 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2463, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 288 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2481, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 163 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2492, 0x00000010}, +#line 980 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2493, 0x00000001}, +#line 1075 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2494, 0x00000001}, +#line 417 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2495, 0x00000010}, + {-1}, {-1}, {-1}, +#line 257 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2499, 0x00000001}, +#line 286 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2500, 0x00001000}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 255 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2507, 0x00000004}, + {-1}, {-1}, +#line 1137 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2510, 0x00000004}, + {-1}, +#line 946 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2512, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 449 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2518, 0x00000001}, + {-1}, {-1}, +#line 30 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2521, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 964 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2534, 0x00000010}, + {-1}, {-1}, +#line 1140 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2537, 0x00000004}, + {-1}, {-1}, {-1}, +#line 254 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2541, 0x00000004}, + {-1}, {-1}, {-1}, +#line 459 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2545, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 31 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2552, 0x00000001}, + {-1}, {-1}, {-1}, +#line 472 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2556, 0x00000002}, + {-1}, {-1}, +#line 354 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2559, 0x00000010}, + {-1}, {-1}, {-1}, +#line 471 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2563, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 1155 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2574, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 771 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2580, 0x00000002}, + {-1}, {-1}, +#line 814 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2583, 0x00000002}, + {-1}, {-1}, +#line 943 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2586, 0x00000002}, + {-1}, {-1}, +#line 289 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2589, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 953 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2605, 0x00000003}, +#line 235 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2606, 0x00000002}, + {-1}, +#line 730 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2608, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1139 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2617, 0x00000004}, +#line 720 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2618, 0x00000002}, + {-1}, {-1}, {-1}, +#line 531 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2622, 0x00000002}, + {-1}, +#line 497 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2624, 0x00000010}, + {-1}, +#line 773 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2626, 0x00000002}, +#line 759 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2627, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1181 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2636, 0x00000010}, + {-1}, {-1}, +#line 966 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2639, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 959 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2645, 0x00000001}, +#line 774 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2646, 0x00000020}, + {-1}, {-1}, +#line 933 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2649, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 658 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2658, 0x00000001}, + {-1}, {-1}, +#line 506 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2661, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 792 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2667, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 757 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2674, 0x00000002}, + {-1}, {-1}, {-1}, +#line 359 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2678, 0x00000001}, +#line 902 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2679, 0x00000001}, + {-1}, {-1}, +#line 594 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2682, 0x00000020}, +#line 1237 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2683, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 793 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2689, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 371 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2697, 0x00000004}, + {-1}, {-1}, {-1}, +#line 717 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2701, 0x00000002}, + {-1}, +#line 1068 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2703, 0x00000002}, +#line 1235 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2704, 0x00000001}, + {-1}, {-1}, +#line 44 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2707, 0x00000002}, + {-1}, +#line 970 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2709, 0x00000003}, + {-1}, {-1}, {-1}, +#line 1152 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2713, 0x00000002}, +#line 1138 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2714, 0x00000004}, + {-1}, +#line 424 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2716, 0x00000004}, + {-1}, {-1}, +#line 807 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2719, 0x00000002}, + {-1}, {-1}, +#line 196 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2722, 0x00000001}, +#line 718 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2723, 0x00000002}, + {-1}, {-1}, +#line 405 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2726, 0x00000004}, + {-1}, {-1}, {-1}, +#line 914 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2730, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 1191 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2744, 0x00000010}, + {-1}, {-1}, {-1}, +#line 529 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2748, 0x00000002}, +#line 921 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2749, 0x00000001}, + {-1}, +#line 600 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2751, 0x00000001}, + {-1}, {-1}, {-1}, +#line 362 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2755, 0x00000010}, + {-1}, {-1}, {-1}, +#line 219 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2759, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 979 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2765, 0x00000004}, +#line 1045 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2766, 0x00000002}, +#line 505 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2767, 0x00000002}, + {-1}, +#line 311 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2769, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 601 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2777, 0x00000002}, +#line 1126 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2778, 0x00000001}, + {-1}, {-1}, +#line 363 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2781, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 839 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2787, 0x00000002}, + {-1}, {-1}, +#line 750 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2790, 0x00000002}, +#line 751 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2791, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 738 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2805, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 348 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2824, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 48 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2835, 0x00000002}, + {-1}, {-1}, +#line 1003 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2838, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 897 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2858, 0x00000001}, + {-1}, +#line 1228 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2860, 0x00000002}, + {-1}, {-1}, +#line 879 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2863, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 865 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2876, 0x00000002}, + {-1}, +#line 862 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2878, 0x00000002}, +#line 209 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2879, 0x00000004}, +#line 864 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2880, 0x00000002}, +#line 523 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2881, 0x00000002}, + {-1}, +#line 870 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2883, 0x00000002}, +#line 1227 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2884, 0x00000010}, + {-1}, +#line 863 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2886, 0x00000002}, +#line 586 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2887, 0x00000002}, + {-1}, {-1}, {-1}, +#line 917 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2891, 0x00000001}, + {-1}, +#line 502 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2893, 0x00000024}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 901 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2900, 0x00000001}, +#line 639 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2901, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 866 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2909, 0x00000002}, + {-1}, {-1}, +#line 317 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2912, 0x00000001}, +#line 816 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2913, 0x00000020}, +#line 118 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2914, 0x00000002}, +#line 937 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2915, 0x00000004}, + {-1}, +#line 882 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2917, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 1016 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2922, 0x00000001}, +#line 427 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2923, 0x00000002}, + {-1}, {-1}, {-1}, +#line 935 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2927, 0x00000006}, +#line 719 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2928, 0x00000002}, + {-1}, +#line 66 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2930, 0x00000001}, + {-1}, +#line 527 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2932, 0x00000004}, + {-1}, +#line 1107 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2934, 0x00000001}, +#line 824 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2935, 0x00000002}, +#line 45 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2936, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1189 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2945, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, +#line 872 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2950, 0x00000002}, + {-1}, +#line 1007 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2952, 0x00000002}, +#line 119 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2953, 0x00000004}, + {-1}, {-1}, {-1}, +#line 490 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2957, 0x00000001}, + {-1}, {-1}, +#line 634 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2960, 0x00000004}, + {-1}, {-1}, +#line 961 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2963, 0x00000010}, + {-1}, +#line 1127 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2965, 0x00000002}, +#line 1062 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2966, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 926 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2977, 0x00000800}, +#line 780 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2978, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 441 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2986, 0x00000001}, + {-1}, {-1}, +#line 638 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2989, 0x00000002}, + {-1}, +#line 1108 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str2991, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 748 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3000, 0x00000002}, +#line 1229 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3001, 0x00000800}, +#line 141 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3002, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 782 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3009, 0x00000002}, +#line 222 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3010, 0x00000008}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 938 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3018, 0x00000004}, +#line 385 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3019, 0x00000005}, + {-1}, +#line 47 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3021, 0x00000002}, + {-1}, {-1}, +#line 1009 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3024, 0x00000004}, + {-1}, {-1}, +#line 590 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3027, 0x00000001}, + {-1}, +#line 161 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3029, 0x00000001}, + {-1}, +#line 1190 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3031, 0x00000010}, + {-1}, +#line 200 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3033, 0x00000010}, +#line 740 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3034, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 114 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3060, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 451 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3068, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 155 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3074, 0x00000002}, +#line 1175 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3075, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1234 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3083, 0x00000020}, + {-1}, {-1}, +#line 995 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3086, 0x00000002}, +#line 1163 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3087, 0x00000002}, + {-1}, +#line 832 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3089, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 131 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3100, 0x00000010}, + {-1}, {-1}, +#line 1174 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3103, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 116 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3110, 0x00000003}, + {-1}, {-1}, {-1}, +#line 687 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3114, 0x00000008}, +#line 1162 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3115, 0x00000002}, +#line 871 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3116, 0x00000002}, + {-1}, +#line 530 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3118, 0x00000010}, + {-1}, +#line 147 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3120, 0x00000010}, + {-1}, {-1}, {-1}, +#line 434 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3124, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 1193 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3129, 0x00000008}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 120 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3135, 0x00000001}, +#line 38 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3136, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 454 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3141, 0x00000001}, + {-1}, {-1}, {-1}, +#line 811 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3145, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 258 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3152, 0x00000002}, + {-1}, {-1}, {-1}, +#line 146 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3156, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 408 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3162, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1212 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3169, 0x00000002}, +#line 41 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3170, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 716 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3185, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1199 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3193, 0x00000010}, +#line 904 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3194, 0x00000001}, +#line 429 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3195, 0x00000004}, + {-1}, {-1}, +#line 310 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3198, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, +#line 878 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3203, 0x00000002}, +#line 855 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3204, 0x00000002}, +#line 361 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3205, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 179 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3212, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 798 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3220, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 173 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3227, 0x00000004}, +#line 801 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3228, 0x00000002}, +#line 537 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3229, 0x00000001}, + {-1}, {-1}, {-1}, +#line 438 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3233, 0x00000004}, + {-1}, {-1}, +#line 876 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3236, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 868 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3243, 0x00000002}, + {-1}, {-1}, +#line 172 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3246, 0x00000004}, + {-1}, +#line 160 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3248, 0x00000002}, +#line 437 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3249, 0x00000004}, +#line 856 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3250, 0x00000020}, + {-1}, {-1}, {-1}, +#line 406 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3254, 0x00000004}, + {-1}, {-1}, +#line 273 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3257, 0x00000001}, + {-1}, {-1}, +#line 791 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3260, 0x00000004}, + {-1}, {-1}, +#line 978 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3263, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 428 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3272, 0x00000002}, + {-1}, +#line 202 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3274, 0x00000002}, + {-1}, {-1}, +#line 126 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3277, 0x00000001}, + {-1}, +#line 936 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3279, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 743 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3286, 0x00000002}, + {-1}, {-1}, +#line 1215 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3289, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 341 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3305, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1214 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3311, 0x00000004}, +#line 903 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3312, 0x00000001}, + {-1}, +#line 983 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3314, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 559 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3319, 0x00000007}, + {-1}, {-1}, {-1}, +#line 1203 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3323, 0x00000006}, + {-1}, +#line 1001 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3325, 0x00000002}, + {-1}, {-1}, +#line 532 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3328, 0x00000004}, + {-1}, {-1}, +#line 1220 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3331, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 1213 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3336, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 692 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3341, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 533 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3346, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 544 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3356, 0x00000001}, + {-1}, {-1}, +#line 810 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3359, 0x00000002}, +#line 1195 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3360, 0x00000008}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 433 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3368, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 130 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3375, 0x00000010}, +#line 622 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3376, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1063 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3385, 0x00000004}, + {-1}, +#line 696 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3387, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 304 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3392, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1082 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3398, 0x00000002}, + {-1}, {-1}, {-1}, +#line 324 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3402, 0x00000001}, + {-1}, {-1}, +#line 729 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3405, 0x00000002}, + {-1}, {-1}, {-1}, +#line 253 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3409, 0x00000001}, + {-1}, {-1}, +#line 1012 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3412, 0x00000001}, +#line 1099 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3413, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 804 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3429, 0x00000002}, + {-1}, {-1}, +#line 499 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3432, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 545 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3438, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1017 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3462, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1122 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3466, 0x00000002}, + {-1}, +#line 849 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3468, 0x00000002}, + {-1}, {-1}, {-1}, +#line 697 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3472, 0x00000002}, +#line 536 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3473, 0x00000004}, +#line 1070 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3474, 0x00000001}, +#line 1200 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3475, 0x00000003}, + {-1}, {-1}, {-1}, {-1}, +#line 912 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3480, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 277 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3487, 0x00000400}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1153 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3497, 0x00000006}, + {-1}, {-1}, +#line 214 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3500, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 233 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3505, 0x00000010}, + {-1}, +#line 662 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3507, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 302 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3515, 0x00000004}, +#line 303 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3516, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 823 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3524, 0x00000002}, + {-1}, +#line 632 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3526, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 909 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3531, 0x00000001}, +#line 372 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3532, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 1084 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3543, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1121 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3550, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 1217 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3562, 0x00000006}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 881 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3581, 0x00000002}, + {-1}, +#line 213 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3583, 0x00000004}, +#line 739 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3584, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 763 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3591, 0x00000002}, + {-1}, +#line 1185 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3593, 0x00000010}, + {-1}, {-1}, +#line 170 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3596, 0x00000004}, +#line 1154 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3597, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 169 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3615, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 861 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3620, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1123 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3628, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 867 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3648, 0x00000002}, + {-1}, +#line 731 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3650, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 985 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3656, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 231 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3664, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 314 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3681, 0x00000002}, + {-1}, +#line 1180 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3683, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, +#line 741 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3688, 0x00000002}, + {-1}, +#line 77 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3690, 0x00000001}, + {-1}, {-1}, {-1}, +#line 1111 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3694, 0x00000001}, + {-1}, +#line 765 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3696, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1112 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3700, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 852 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3708, 0x00000002}, + {-1}, {-1}, {-1}, +#line 495 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3712, 0x00000010}, + {-1}, +#line 496 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3714, 0x00000010}, + {-1}, +#line 448 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3716, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 701 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3725, 0x00000002}, +#line 390 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3726, 0x00000004}, + {-1}, +#line 60 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3728, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 221 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3737, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 667 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3748, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 962 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3753, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 981 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3759, 0x00000004}, + {-1}, +#line 670 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3761, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1058 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3767, 0x00000004}, + {-1}, +#line 672 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3769, 0x00000002}, + {-1}, +#line 702 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3771, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 127 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3778, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 1125 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3791, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 452 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3799, 0x00000001}, + {-1}, {-1}, {-1}, +#line 306 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3803, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1103 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3827, 0x00000800}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 225 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3835, 0x00000001}, + {-1}, {-1}, +#line 760 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3838, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 566 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3844, 0x00000007}, + {-1}, {-1}, {-1}, {-1}, +#line 1204 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3849, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1143 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3853, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 756 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3866, 0x00000002}, +#line 1144 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3867, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 698 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3878, 0x00000002}, + {-1}, +#line 1188 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3880, 0x00000002}, +#line 1205 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3881, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 869 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3890, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 704 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3895, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 1092 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3900, 0x00000002}, +#line 1239 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3901, 0x00000008}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1231 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3927, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 367 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3937, 0x00000002}, + {-1}, +#line 283 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3939, 0x00000001}, + {-1}, +#line 924 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3941, 0x00000001}, + {-1}, +#line 84 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3943, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 724 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3961, 0x00000002}, + {-1}, +#line 1194 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3963, 0x00000008}, +#line 725 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3964, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 106 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3992, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 125 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str3998, 0x00000001}, + {-1}, {-1}, {-1}, +#line 305 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4002, 0x00000004}, + {-1}, {-1}, +#line 245 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4005, 0x00000002}, + {-1}, {-1}, +#line 1032 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4008, 0x00000002}, + {-1}, +#line 1091 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4010, 0x00000002}, + {-1}, {-1}, +#line 1008 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4013, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 908 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4019, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 789 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4028, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 693 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4034, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 489 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4054, 0x00000002}, + {-1}, +#line 342 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4056, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 151 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4063, 0x00000003}, +#line 1021 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4064, 0x00000003}, + {-1}, {-1}, {-1}, +#line 951 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4068, 0x00000006}, + {-1}, {-1}, {-1}, +#line 660 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4072, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 686 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4078, 0x00000020}, + {-1}, +#line 1072 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4080, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 890 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4088, 0x00000001}, + {-1}, {-1}, +#line 1198 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4091, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 830 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4097, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 963 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4102, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1172 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4106, 0x00000001}, + {-1}, {-1}, {-1}, +#line 891 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4110, 0x00000001}, + {-1}, {-1}, {-1}, +#line 1081 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4114, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 1102 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4137, 0x00000001}, + {-1}, {-1}, {-1}, +#line 335 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4141, 0x00000001}, + {-1}, +#line 685 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4143, 0x00000001}, + {-1}, +#line 1209 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4145, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 998 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4158, 0x00000002}, + {-1}, {-1}, +#line 1206 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4161, 0x00000002}, + {-1}, {-1}, +#line 78 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4164, 0x00000400}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 898 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4174, 0x00000001}, + {-1}, +#line 83 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4176, 0x00000001}, + {-1}, +#line 419 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4178, 0x00000004}, + {-1}, +#line 1173 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4180, 0x00000001}, + {-1}, {-1}, {-1}, +#line 1169 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4184, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1170 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4188, 0x00000002}, +#line 383 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4189, 0x00000002}, + {-1}, {-1}, +#line 1171 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4192, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 509 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4201, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 279 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4209, 0x00000010}, + {-1}, {-1}, +#line 1166 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4212, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 976 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4218, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 152 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4225, 0x00000002}, + {-1}, {-1}, +#line 312 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4228, 0x00000001}, + {-1}, +#line 543 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4230, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1202 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4234, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 393 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4243, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 91 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4248, 0x00000001}, + {-1}, +#line 668 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4250, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 553 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4257, 0x00000002}, + {-1}, +#line 821 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4259, 0x00000002}, + {-1}, {-1}, {-1}, +#line 673 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4263, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1219 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4280, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1167 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4286, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1168 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4290, 0x00000002}, +#line 1004 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4291, 0x00000006}, +#line 467 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4292, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 947 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4305, 0x00000004}, + {-1}, +#line 71 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4307, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 844 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4317, 0x00000002}, +#line 732 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4318, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 604 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4324, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 1120 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4329, 0x00000008}, + {-1}, {-1}, +#line 705 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4332, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1014 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4336, 0x00000002}, +#line 79 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4337, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 671 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4357, 0x00000001}, + {-1}, {-1}, {-1}, +#line 416 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4361, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 134 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4381, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 415 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4386, 0x00000004}, + {-1}, {-1}, {-1}, +#line 1179 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4390, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1104 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4396, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 457 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4417, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 244 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4427, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 73 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4432, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 313 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4438, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 333 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4443, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 100 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4448, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 249 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4455, 0x00000002}, + {-1}, +#line 1207 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4457, 0x00000020}, + {-1}, {-1}, {-1}, +#line 541 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4461, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 742 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4467, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 95 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4473, 0x00000002}, + {-1}, {-1}, {-1}, +#line 343 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4477, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1141 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4483, 0x00000010}, + {-1}, +#line 121 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4485, 0x00000001}, +#line 331 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4486, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 414 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4500, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 411 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4506, 0x00000004}, +#line 203 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4507, 0x00000002}, + {-1}, {-1}, {-1}, +#line 149 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4511, 0x00000001}, + {-1}, +#line 493 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4513, 0x00000004}, + {-1}, {-1}, +#line 1176 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4516, 0x00000004}, + {-1}, {-1}, +#line 76 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4519, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 412 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4524, 0x00000002}, + {-1}, {-1}, +#line 37 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4527, 0x00000010}, +#line 375 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4528, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 500 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4544, 0x00000004}, +#line 75 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4545, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 722 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4550, 0x00000002}, + {-1}, {-1}, +#line 220 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4553, 0x00000004}, + {-1}, {-1}, {-1}, +#line 1033 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4557, 0x00000002}, + {-1}, +#line 721 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4559, 0x00000002}, + {-1}, {-1}, {-1}, +#line 700 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4563, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 663 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4569, 0x00000002}, + {-1}, +#line 122 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4571, 0x00000002}, +#line 889 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4572, 0x00000001}, + {-1}, {-1}, {-1}, +#line 399 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4576, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 918 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4591, 0x00000001}, + {-1}, +#line 1052 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4593, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 309 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4614, 0x00000010}, + {-1}, +#line 920 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4616, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 540 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4630, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1178 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4646, 0x00000002}, + {-1}, {-1}, +#line 965 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4649, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 714 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4666, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 1210 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4671, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 972 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4677, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 820 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4684, 0x00000002}, + {-1}, {-1}, {-1}, +#line 162 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4688, 0x00000800}, + {-1}, {-1}, {-1}, +#line 403 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4692, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 973 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4699, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 46 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4706, 0x00000002}, +#line 681 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4707, 0x0000000a}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 74 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4725, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 575 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4732, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 752 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4750, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 226 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4758, 0x00000002}, + {-1}, {-1}, {-1}, +#line 123 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4762, 0x00000004}, + {-1}, {-1}, +#line 571 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4765, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 68 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4785, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 67 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4810, 0x00000004}, + {-1}, {-1}, {-1}, +#line 969 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4814, 0x00000002}, + {-1}, +#line 885 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4816, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 143 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4821, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 939 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4833, 0x00000400}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 1109 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4846, 0x00000001}, + {-1}, +#line 145 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4848, 0x00000001}, +#line 766 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4849, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 227 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4870, 0x00000004}, + {-1}, +#line 1088 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4872, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 218 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4884, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 1177 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4896, 0x00000002}, +#line 1011 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4897, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 895 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4908, 0x00000001}, +#line 150 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4909, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 142 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4927, 0x00000002}, + {-1}, {-1}, {-1}, +#line 1149 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4931, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 368 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4945, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 646 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4953, 0x00000003}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 39 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4966, 0x00000004}, + {-1}, {-1}, {-1}, +#line 837 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4970, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 1208 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4983, 0x00000020}, + {-1}, +#line 230 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4985, 0x00000004}, +#line 398 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str4986, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 435 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5022, 0x00000004}, + {-1}, {-1}, +#line 69 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5025, 0x00000004}, + {-1}, {-1}, +#line 128 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5028, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 40 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5038, 0x00000004}, + {-1}, {-1}, +#line 602 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5041, 0x00000002}, + {-1}, {-1}, {-1}, +#line 436 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5045, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 899 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5057, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 280 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5064, 0x00000004}, + {-1}, {-1}, +#line 439 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5067, 0x00000004}, + {-1}, {-1}, +#line 206 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5070, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 455 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5081, 0x00000008}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 910 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5087, 0x00000001}, +#line 761 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5088, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1211 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5096, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 886 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5112, 0x00000001}, + {-1}, +#line 706 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5114, 0x00000002}, +#line 80 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5115, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 578 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5132, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1006 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5138, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 990 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5144, 0x00000001}, + {-1}, +#line 605 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5146, 0x00000020}, + {-1}, {-1}, +#line 124 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5149, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 984 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5156, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1076 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5164, 0x00000004}, + {-1}, {-1}, +#line 968 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5167, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 395 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5176, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1216 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5184, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 394 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5194, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 967 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5199, 0x00000008}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1232 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5207, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, +#line 840 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5212, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 905 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5225, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 841 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5240, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 89 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5253, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 65 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5266, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 144 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5311, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 892 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5330, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 664 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5356, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 986 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5382, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 1073 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5404, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 72 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5426, 0x00000001}, + {-1}, {-1}, +#line 534 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5429, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 992 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5485, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 846 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5535, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 511 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5594, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, +#line 32 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5599, 0x00000001}, +#line 728 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5600, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 87 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5606, 0x00000005}, + {-1}, {-1}, +#line 501 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5609, 0x00000004}, + {-1}, +#line 877 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5611, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 982 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5624, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 727 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5632, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 33 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5662, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 132 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5698, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, +#line 1028 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5703, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1015 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5709, 0x00000001}, +#line 391 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5710, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1145 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5729, 0x00000001}, + {-1}, +#line 376 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5731, 0x00000001}, + {-1}, {-1}, {-1}, +#line 539 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5735, 0x00000001}, + {-1}, {-1}, +#line 462 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5738, 0x00000400}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1124 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5755, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1223 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5789, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 603 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5820, 0x00000020}, + {-1}, {-1}, {-1}, +#line 1224 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5824, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1225 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5850, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 911 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5870, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 958 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5887, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 85 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5900, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 307 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5925, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 175 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5936, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 174 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5961, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 822 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5975, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1230 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5982, 0x00000010}, + {-1}, +#line 241 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5984, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1118 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str5999, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 1069 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6031, 0x00000006}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1056 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6038, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 379 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6048, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 887 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6053, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1046 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6062, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 1090 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6083, 0x00000002}, +#line 669 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6084, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 535 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6096, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 325 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6108, 0x00000001}, + {-1}, {-1}, {-1}, +#line 1043 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6112, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 790 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6123, 0x00000004}, + {-1}, +#line 703 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6125, 0x00000002}, + {-1}, +#line 563 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6127, 0x00000007}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 133 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6140, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1024 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6147, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 117 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6176, 0x00000003}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 458 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6185, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, +#line 92 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6190, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1119 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6226, 0x00000001}, +#line 768 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6227, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 137 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6241, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 138 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6263, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 61 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6272, 0x00000002}, + {-1}, {-1}, +#line 246 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6275, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 140 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6300, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 991 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6316, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 432 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6333, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 1201 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6452, 0x00000001}, + {-1}, {-1}, {-1}, +#line 1147 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6456, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 1242 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6512, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 240 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6534, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 82 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6553, 0x00000001}, + {-1}, {-1}, {-1}, +#line 954 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6557, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 326 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6578, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 229 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6584, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 1241 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6631, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 971 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6642, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 153 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6655, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, +#line 726 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6660, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 1218 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6708, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 747 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6745, 0x00000020}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 201 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6761, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 977 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6863, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 135 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6924, 0x00000004}, + {-1}, {-1}, +#line 281 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6927, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1071 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6943, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 699 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6948, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 923 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str6980, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 136 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7088, 0x00000004}, +#line 492 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7089, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 90 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7100, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 960 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7162, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1059 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7204, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 413 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7274, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 819 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7282, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 402 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7352, 0x00000002}, + {-1}, +#line 999 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7354, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 264 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7405, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 148 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7415, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 88 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7453, 0x00000005}, + {-1}, {-1}, {-1}, +#line 987 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7457, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 228 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7485, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 270 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7556, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 392 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7573, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 538 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7579, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 340 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7611, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 952 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7656, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 268 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7717, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1067 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7815, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1089 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7842, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 746 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7947, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 1086 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7958, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 688 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str7979, 0x00000009}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, +#line 1087 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8002, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1186 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8036, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 893 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8047, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 386 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8146, 0x00000007}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1060 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8174, 0x00000004}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 129 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8293, 0x00000002}, + {-1}, {-1}, {-1}, +#line 715 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8297, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 248 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8431, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 267 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8465, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 1010 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8639, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 1031 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8822, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 154 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8840, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 298 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8911, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 1226 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str8920, 0x00000007}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, +#line 139 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str9004, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 271 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str9058, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 900 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str9334, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 957 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str9480, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, +#line 956 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str9485, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, +#line 955 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str9536, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 888 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str9684, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 86 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str10060, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 1222 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str10341, 0x00000001}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 297 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str10494, 0x00000010}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 579 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str10575, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 265 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str11056, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, +#line 266 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str11076, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 269 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str11085, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, +#line 272 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str11119, 0x00000002}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, +#line 975 "fcgenericfamily.gperf" + {(int)(size_t)&((struct FcConstFamilyNamePool_t *)0)->FcConstFamilyNamePool_str12005, 0x00000001} + }; +#if (defined __GNUC__ && __GNUC__ + (__GNUC_MINOR__ >= 6) > 4) || (defined __clang__ && __clang_major__ >= 3) +#pragma GCC diagnostic pop +#endif + + if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) + { + register unsigned int key = fc_generic_family_hash (str, len); + + if (key <= MAX_HASH_VALUE) + { + register int o = wordlist[key].name; + if (o >= 0) + { + register const char *s = o + FcConstFamilyNamePool; + + if ((((unsigned char)*str ^ (unsigned char)*s) & ~32) == 0 && !gperf_case_strcmp (str, s)) + return &wordlist[key]; + } + } + } + return (struct FcGenericFamilyEntry *) 0; +} +#line 1247 "fcgenericfamily.gperf" + diff --git a/pkg/fontconfig/override/fc-lang/fclang.h b/pkg/fontconfig/override/fc-lang/fclang.h new file mode 100644 index 000000000..dbe2a8851 --- /dev/null +++ b/pkg/fontconfig/override/fc-lang/fclang.h @@ -0,0 +1,5586 @@ +/* + * fontconfig/fc-lang/fclang.tmpl.h + * + * Copyright © 2002 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the author(s) not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors make no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +/* total size: 1768 unique leaves: 804 */ + +#define LEAF0 (339 * sizeof (FcLangCharSet)) +#define OFF0 (LEAF0 + 804 * sizeof (FcCharLeaf)) +#define NUM0 (OFF0 + 987 * sizeof (uintptr_t)) +#define SET(n) (n * sizeof (FcLangCharSet) + offsetof (FcLangCharSet, charset)) +#define OFF(s,o) (OFF0 + o * sizeof (uintptr_t) - SET(s)) +#define NUM(s,n) (NUM0 + n * sizeof (FcChar16) - SET(s)) +#define LEAF(o,l) (LEAF0 + l * sizeof (FcCharLeaf) - (OFF0 + o * sizeof (intptr_t))) +#define fcLangCharSets (fcLangData.langCharSets) +#define fcLangCharSetIndices (fcLangData.langIndices) +#define fcLangCharSetIndicesInv (fcLangData.langIndicesInv) + +static const struct { + FcLangCharSet langCharSets[339]; + FcCharLeaf leaves[804]; + uintptr_t leaf_offsets[987]; + FcChar16 numbers[987]; + FcChar16 langIndices[339]; + FcChar16 langIndicesInv[339]; +} fcLangData = { +{ + { "aa", { FC_REF_CONSTANT, 1, OFF(0,0), NUM(0,0) } }, /* 0 */ + { "ab", { FC_REF_CONSTANT, 1, OFF(1,1), NUM(1,1) } }, /* 1 */ + { "ae", { FC_REF_CONSTANT, 1, OFF(2,2), NUM(2,2) } }, /* 2 */ + { "af", { FC_REF_CONSTANT, 2, OFF(3,3), NUM(3,3) } }, /* 3 */ + { "agr", { FC_REF_CONSTANT, 1, OFF(4,5), NUM(4,5) } }, /* 4 */ + { "aho", { FC_REF_CONSTANT, 1, OFF(5,6), NUM(5,6) } }, /* 5 */ + { "ak", { FC_REF_CONSTANT, 5, OFF(6,7), NUM(6,7) } }, /* 6 */ + { "akk", { FC_REF_CONSTANT, 6, OFF(7,12), NUM(7,12) } }, /* 7 */ + { "am", { FC_REF_CONSTANT, 2, OFF(8,18), NUM(8,18) } }, /* 8 */ + { "an", { FC_REF_CONSTANT, 1, OFF(9,20), NUM(9,20) } }, /* 9 */ + { "anp", { FC_REF_CONSTANT, 1, OFF(10,21), NUM(10,21) } }, /* 10 */ + { "ar", { FC_REF_CONSTANT, 1, OFF(11,22), NUM(11,22) } }, /* 11 */ + { "arc", { FC_REF_CONSTANT, 1, OFF(12,23), NUM(12,23) } }, /* 12 */ + { "as", { FC_REF_CONSTANT, 1, OFF(13,24), NUM(13,24) } }, /* 13 */ + { "ast", { FC_REF_CONSTANT, 2, OFF(14,25), NUM(14,25) } }, /* 14 */ + { "av", { FC_REF_CONSTANT, 1, OFF(15,27), NUM(15,27) } }, /* 15 */ + { "ay", { FC_REF_CONSTANT, 1, OFF(16,28), NUM(16,28) } }, /* 16 */ + { "ayc", { FC_REF_CONSTANT, 1, OFF(17,29), NUM(17,29) } }, /* 17 */ + { "az-az", { FC_REF_CONSTANT, 3, OFF(18,30), NUM(18,30) } }, /* 18 */ + { "az-ir", { FC_REF_CONSTANT, 1, OFF(19,33), NUM(19,33) } }, /* 19 */ + { "ba", { FC_REF_CONSTANT, 1, OFF(20,34), NUM(20,34) } }, /* 20 */ + { "ban", { FC_REF_CONSTANT, 1, OFF(21,35), NUM(21,35) } }, /* 21 */ + { "bax", { FC_REF_CONSTANT, 1, OFF(22,36), NUM(22,36) } }, /* 22 */ + { "be", { FC_REF_CONSTANT, 1, OFF(23,37), NUM(23,37) } }, /* 23 */ + { "bem", { FC_REF_CONSTANT, 1, OFF(24,38), NUM(24,38) } }, /* 24 */ + { "ber-dz", { FC_REF_CONSTANT, 4, OFF(25,39), NUM(25,39) } }, /* 25 */ + { "ber-ma", { FC_REF_CONSTANT, 1, OFF(26,43), NUM(26,43) } }, /* 26 */ + { "bg", { FC_REF_CONSTANT, 1, OFF(27,44), NUM(27,44) } }, /* 27 */ + { "bh", { FC_REF_CONSTANT, 1, OFF(28,21), NUM(28,21) } }, /* 28 */ + { "bhb", { FC_REF_CONSTANT, 1, OFF(29,21), NUM(29,21) } }, /* 29 */ + { "bho", { FC_REF_CONSTANT, 1, OFF(30,21), NUM(30,21) } }, /* 30 */ + { "bi", { FC_REF_CONSTANT, 1, OFF(31,45), NUM(31,45) } }, /* 31 */ + { "bin", { FC_REF_CONSTANT, 3, OFF(32,46), NUM(32,46) } }, /* 32 */ + { "bku", { FC_REF_CONSTANT, 1, OFF(33,49), NUM(33,49) } }, /* 33 */ + { "blt", { FC_REF_CONSTANT, 1, OFF(34,50), NUM(34,50) } }, /* 34 */ + { "bm", { FC_REF_CONSTANT, 3, OFF(35,51), NUM(35,51) } }, /* 35 */ + { "bn", { FC_REF_CONSTANT, 1, OFF(36,54), NUM(36,54) } }, /* 36 */ + { "bo", { FC_REF_CONSTANT, 1, OFF(37,55), NUM(37,55) } }, /* 37 */ + { "br", { FC_REF_CONSTANT, 1, OFF(38,56), NUM(38,56) } }, /* 38 */ + { "brx", { FC_REF_CONSTANT, 1, OFF(39,57), NUM(39,57) } }, /* 39 */ + { "bs", { FC_REF_CONSTANT, 2, OFF(40,58), NUM(40,58) } }, /* 40 */ + { "bua", { FC_REF_CONSTANT, 1, OFF(41,60), NUM(41,60) } }, /* 41 */ + { "byn", { FC_REF_CONSTANT, 2, OFF(42,61), NUM(42,61) } }, /* 42 */ + { "ca", { FC_REF_CONSTANT, 2, OFF(43,63), NUM(43,63) } }, /* 43 */ + { "ccp", { FC_REF_CONSTANT, 1, OFF(44,65), NUM(44,65) } }, /* 44 */ + { "ce", { FC_REF_CONSTANT, 1, OFF(45,27), NUM(45,27) } }, /* 45 */ + { "ch", { FC_REF_CONSTANT, 1, OFF(46,66), NUM(46,66) } }, /* 46 */ + { "chm", { FC_REF_CONSTANT, 1, OFF(47,67), NUM(47,67) } }, /* 47 */ + { "chr", { FC_REF_CONSTANT, 1, OFF(48,68), NUM(48,68) } }, /* 48 */ + { "cjm", { FC_REF_CONSTANT, 1, OFF(49,69), NUM(49,69) } }, /* 49 */ + { "ckb", { FC_REF_CONSTANT, 1, OFF(50,70), NUM(50,70) } }, /* 50 */ + { "cmn", { FC_REF_CONSTANT, 83, OFF(51,71), NUM(51,71) } }, /* 51 */ + { "co", { FC_REF_CONSTANT, 2, OFF(52,154), NUM(52,154) } }, /* 52 */ + { "cop", { FC_REF_CONSTANT, 2, OFF(53,156), NUM(53,156) } }, /* 53 */ + { "crh", { FC_REF_CONSTANT, 2, OFF(54,158), NUM(54,158) } }, /* 54 */ + { "cs", { FC_REF_CONSTANT, 2, OFF(55,160), NUM(55,160) } }, /* 55 */ + { "csb", { FC_REF_CONSTANT, 2, OFF(56,162), NUM(56,162) } }, /* 56 */ + { "cu", { FC_REF_CONSTANT, 1, OFF(57,164), NUM(57,164) } }, /* 57 */ + { "cv", { FC_REF_CONSTANT, 2, OFF(58,165), NUM(58,165) } }, /* 58 */ + { "cy", { FC_REF_CONSTANT, 3, OFF(59,167), NUM(59,167) } }, /* 59 */ + { "da", { FC_REF_CONSTANT, 1, OFF(60,170), NUM(60,170) } }, /* 60 */ + { "de", { FC_REF_CONSTANT, 1, OFF(61,171), NUM(61,171) } }, /* 61 */ + { "dmf", { FC_REF_CONSTANT, 1, OFF(62,172), NUM(62,172) } }, /* 62 */ + { "doi", { FC_REF_CONSTANT, 1, OFF(63,173), NUM(63,173) } }, /* 63 */ + { "dsb", { FC_REF_CONSTANT, 2, OFF(64,160), NUM(64,160) } }, /* 64 */ + { "dv", { FC_REF_CONSTANT, 1, OFF(65,174), NUM(65,174) } }, /* 65 */ + { "dz", { FC_REF_CONSTANT, 1, OFF(66,55), NUM(66,55) } }, /* 66 */ + { "ecy", { FC_REF_CONSTANT, 1, OFF(67,175), NUM(67,175) } }, /* 67 */ + { "ee", { FC_REF_CONSTANT, 4, OFF(68,176), NUM(68,176) } }, /* 68 */ + { "egy", { FC_REF_CONSTANT, 5, OFF(69,180), NUM(69,180) } }, /* 69 */ + { "eky", { FC_REF_CONSTANT, 1, OFF(70,185), NUM(70,185) } }, /* 70 */ + { "el", { FC_REF_CONSTANT, 1, OFF(71,186), NUM(71,186) } }, /* 71 */ + { "en", { FC_REF_CONSTANT, 1, OFF(72,187), NUM(72,187) } }, /* 72 */ + { "eo", { FC_REF_CONSTANT, 2, OFF(73,188), NUM(73,188) } }, /* 73 */ + { "es", { FC_REF_CONSTANT, 1, OFF(74,20), NUM(74,20) } }, /* 74 */ + { "et", { FC_REF_CONSTANT, 2, OFF(75,190), NUM(75,190) } }, /* 75 */ + { "ett", { FC_REF_CONSTANT, 1, OFF(76,192), NUM(76,192) } }, /* 76 */ + { "eu", { FC_REF_CONSTANT, 1, OFF(77,193), NUM(77,193) } }, /* 77 */ + { "fa", { FC_REF_CONSTANT, 1, OFF(78,33), NUM(78,33) } }, /* 78 */ + { "fat", { FC_REF_CONSTANT, 5, OFF(79,7), NUM(79,7) } }, /* 79 */ + { "ff", { FC_REF_CONSTANT, 3, OFF(80,194), NUM(80,194) } }, /* 80 */ + { "fi", { FC_REF_CONSTANT, 2, OFF(81,197), NUM(81,197) } }, /* 81 */ + { "fil", { FC_REF_CONSTANT, 1, OFF(82,199), NUM(82,199) } }, /* 82 */ + { "fj", { FC_REF_CONSTANT, 1, OFF(83,38), NUM(83,38) } }, /* 83 */ + { "fo", { FC_REF_CONSTANT, 1, OFF(84,200), NUM(84,200) } }, /* 84 */ + { "fr", { FC_REF_CONSTANT, 2, OFF(85,154), NUM(85,154) } }, /* 85 */ + { "fur", { FC_REF_CONSTANT, 1, OFF(86,201), NUM(86,201) } }, /* 86 */ + { "fy", { FC_REF_CONSTANT, 1, OFF(87,202), NUM(87,202) } }, /* 87 */ + { "ga", { FC_REF_CONSTANT, 3, OFF(88,203), NUM(88,203) } }, /* 88 */ + { "gd", { FC_REF_CONSTANT, 1, OFF(89,206), NUM(89,206) } }, /* 89 */ + { "gez", { FC_REF_CONSTANT, 2, OFF(90,207), NUM(90,207) } }, /* 90 */ + { "gl", { FC_REF_CONSTANT, 1, OFF(91,20), NUM(91,20) } }, /* 91 */ + { "gmy", { FC_REF_CONSTANT, 1, OFF(92,209), NUM(92,209) } }, /* 92 */ + { "gn", { FC_REF_CONSTANT, 3, OFF(93,210), NUM(93,210) } }, /* 93 */ + { "got", { FC_REF_CONSTANT, 1, OFF(94,213), NUM(94,213) } }, /* 94 */ + { "gu", { FC_REF_CONSTANT, 1, OFF(95,214), NUM(95,214) } }, /* 95 */ + { "gv", { FC_REF_CONSTANT, 1, OFF(96,215), NUM(96,215) } }, /* 96 */ + { "ha", { FC_REF_CONSTANT, 3, OFF(97,216), NUM(97,216) } }, /* 97 */ + { "hak", { FC_REF_CONSTANT, 83, OFF(98,71), NUM(98,71) } }, /* 98 */ + { "haw", { FC_REF_CONSTANT, 3, OFF(99,219), NUM(99,219) } }, /* 99 */ + { "he", { FC_REF_CONSTANT, 1, OFF(100,222), NUM(100,222) } }, /* 100 */ + { "hi", { FC_REF_CONSTANT, 1, OFF(101,21), NUM(101,21) } }, /* 101 */ + { "hif", { FC_REF_CONSTANT, 1, OFF(102,21), NUM(102,21) } }, /* 102 */ + { "hit", { FC_REF_CONSTANT, 6, OFF(103,12), NUM(103,12) } }, /* 103 */ + { "hlu", { FC_REF_CONSTANT, 3, OFF(104,223), NUM(104,223) } }, /* 104 */ + { "hmd", { FC_REF_CONSTANT, 1, OFF(105,226), NUM(105,226) } }, /* 105 */ + { "hne", { FC_REF_CONSTANT, 1, OFF(106,21), NUM(106,21) } }, /* 106 */ + { "hnn", { FC_REF_CONSTANT, 1, OFF(107,227), NUM(107,227) } }, /* 107 */ + { "ho", { FC_REF_CONSTANT, 1, OFF(108,38), NUM(108,38) } }, /* 108 */ + { "hoc", { FC_REF_CONSTANT, 1, OFF(109,228), NUM(109,228) } }, /* 109 */ + { "hr", { FC_REF_CONSTANT, 2, OFF(110,58), NUM(110,58) } }, /* 110 */ + { "hsb", { FC_REF_CONSTANT, 2, OFF(111,229), NUM(111,229) } }, /* 111 */ + { "ht", { FC_REF_CONSTANT, 1, OFF(112,231), NUM(112,231) } }, /* 112 */ + { "hu", { FC_REF_CONSTANT, 2, OFF(113,232), NUM(113,232) } }, /* 113 */ + { "hy", { FC_REF_CONSTANT, 1, OFF(114,234), NUM(114,234) } }, /* 114 */ + { "hz", { FC_REF_CONSTANT, 3, OFF(115,235), NUM(115,235) } }, /* 115 */ + { "ia", { FC_REF_CONSTANT, 1, OFF(116,38), NUM(116,38) } }, /* 116 */ + { "id", { FC_REF_CONSTANT, 1, OFF(117,238), NUM(117,238) } }, /* 117 */ + { "ie", { FC_REF_CONSTANT, 1, OFF(118,239), NUM(118,239) } }, /* 118 */ + { "ig", { FC_REF_CONSTANT, 2, OFF(119,240), NUM(119,240) } }, /* 119 */ + { "ii", { FC_REF_CONSTANT, 5, OFF(120,242), NUM(120,242) } }, /* 120 */ + { "ik", { FC_REF_CONSTANT, 1, OFF(121,247), NUM(121,247) } }, /* 121 */ + { "io", { FC_REF_CONSTANT, 1, OFF(122,38), NUM(122,38) } }, /* 122 */ + { "is", { FC_REF_CONSTANT, 1, OFF(123,248), NUM(123,248) } }, /* 123 */ + { "it", { FC_REF_CONSTANT, 1, OFF(124,249), NUM(124,249) } }, /* 124 */ + { "iu", { FC_REF_CONSTANT, 3, OFF(125,250), NUM(125,250) } }, /* 125 */ + { "ja", { FC_REF_CONSTANT, 83, OFF(126,253), NUM(126,253) } }, /* 126 */ + { "jv", { FC_REF_CONSTANT, 1, OFF(127,336), NUM(127,336) } }, /* 127 */ + { "ka", { FC_REF_CONSTANT, 1, OFF(128,337), NUM(128,337) } }, /* 128 */ + { "kaa", { FC_REF_CONSTANT, 1, OFF(129,338), NUM(129,338) } }, /* 129 */ + { "kab", { FC_REF_CONSTANT, 4, OFF(130,39), NUM(130,39) } }, /* 130 */ + { "kaw", { FC_REF_CONSTANT, 1, OFF(131,339), NUM(131,339) } }, /* 131 */ + { "khb", { FC_REF_CONSTANT, 1, OFF(132,340), NUM(132,340) } }, /* 132 */ + { "ki", { FC_REF_CONSTANT, 2, OFF(133,341), NUM(133,341) } }, /* 133 */ + { "kj", { FC_REF_CONSTANT, 1, OFF(134,38), NUM(134,38) } }, /* 134 */ + { "kk", { FC_REF_CONSTANT, 1, OFF(135,343), NUM(135,343) } }, /* 135 */ + { "kl", { FC_REF_CONSTANT, 2, OFF(136,344), NUM(136,344) } }, /* 136 */ + { "km", { FC_REF_CONSTANT, 1, OFF(137,346), NUM(137,346) } }, /* 137 */ + { "kn", { FC_REF_CONSTANT, 1, OFF(138,347), NUM(138,347) } }, /* 138 */ + { "ko", { FC_REF_CONSTANT, 45, OFF(139,348), NUM(139,348) } }, /* 139 */ + { "kok", { FC_REF_CONSTANT, 1, OFF(140,21), NUM(140,21) } }, /* 140 */ + { "kr", { FC_REF_CONSTANT, 3, OFF(141,393), NUM(141,393) } }, /* 141 */ + { "ks", { FC_REF_CONSTANT, 1, OFF(142,396), NUM(142,396) } }, /* 142 */ + { "ku-am", { FC_REF_CONSTANT, 2, OFF(143,397), NUM(143,397) } }, /* 143 */ + { "ku-iq", { FC_REF_CONSTANT, 1, OFF(144,70), NUM(144,70) } }, /* 144 */ + { "ku-ir", { FC_REF_CONSTANT, 1, OFF(145,70), NUM(145,70) } }, /* 145 */ + { "ku-tr", { FC_REF_CONSTANT, 2, OFF(146,399), NUM(146,399) } }, /* 146 */ + { "kum", { FC_REF_CONSTANT, 1, OFF(147,401), NUM(147,401) } }, /* 147 */ + { "kv", { FC_REF_CONSTANT, 1, OFF(148,402), NUM(148,402) } }, /* 148 */ + { "kw", { FC_REF_CONSTANT, 3, OFF(149,403), NUM(149,403) } }, /* 149 */ + { "kwm", { FC_REF_CONSTANT, 1, OFF(150,38), NUM(150,38) } }, /* 150 */ + { "ky", { FC_REF_CONSTANT, 1, OFF(151,406), NUM(151,406) } }, /* 151 */ + { "la", { FC_REF_CONSTANT, 2, OFF(152,407), NUM(152,407) } }, /* 152 */ + { "lah", { FC_REF_CONSTANT, 1, OFF(153,409), NUM(153,409) } }, /* 153 */ + { "lb", { FC_REF_CONSTANT, 1, OFF(154,410), NUM(154,410) } }, /* 154 */ + { "lep", { FC_REF_CONSTANT, 1, OFF(155,411), NUM(155,411) } }, /* 155 */ + { "lez", { FC_REF_CONSTANT, 1, OFF(156,27), NUM(156,27) } }, /* 156 */ + { "lg", { FC_REF_CONSTANT, 2, OFF(157,412), NUM(157,412) } }, /* 157 */ + { "li", { FC_REF_CONSTANT, 1, OFF(158,414), NUM(158,414) } }, /* 158 */ + { "lif", { FC_REF_CONSTANT, 1, OFF(159,415), NUM(159,415) } }, /* 159 */ + { "lij", { FC_REF_CONSTANT, 1, OFF(160,416), NUM(160,416) } }, /* 160 */ + { "lis", { FC_REF_CONSTANT, 1, OFF(161,417), NUM(161,417) } }, /* 161 */ + { "ln", { FC_REF_CONSTANT, 4, OFF(162,418), NUM(162,418) } }, /* 162 */ + { "lo", { FC_REF_CONSTANT, 1, OFF(163,422), NUM(163,422) } }, /* 163 */ + { "lt", { FC_REF_CONSTANT, 2, OFF(164,423), NUM(164,423) } }, /* 164 */ + { "lv", { FC_REF_CONSTANT, 2, OFF(165,425), NUM(165,425) } }, /* 165 */ + { "lzh", { FC_REF_CONSTANT, 83, OFF(166,71), NUM(166,71) } }, /* 166 */ + { "mag", { FC_REF_CONSTANT, 1, OFF(167,21), NUM(167,21) } }, /* 167 */ + { "mai", { FC_REF_CONSTANT, 1, OFF(168,21), NUM(168,21) } }, /* 168 */ + { "mfe", { FC_REF_CONSTANT, 2, OFF(169,154), NUM(169,154) } }, /* 169 */ + { "mg", { FC_REF_CONSTANT, 1, OFF(170,427), NUM(170,427) } }, /* 170 */ + { "mh", { FC_REF_CONSTANT, 2, OFF(171,428), NUM(171,428) } }, /* 171 */ + { "mhr", { FC_REF_CONSTANT, 1, OFF(172,401), NUM(172,401) } }, /* 172 */ + { "mi", { FC_REF_CONSTANT, 3, OFF(173,430), NUM(173,430) } }, /* 173 */ + { "mid", { FC_REF_CONSTANT, 1, OFF(174,433), NUM(174,433) } }, /* 174 */ + { "miq", { FC_REF_CONSTANT, 3, OFF(175,434), NUM(175,434) } }, /* 175 */ + { "mjw", { FC_REF_CONSTANT, 1, OFF(176,187), NUM(176,187) } }, /* 176 */ + { "mk", { FC_REF_CONSTANT, 1, OFF(177,437), NUM(177,437) } }, /* 177 */ + { "ml", { FC_REF_CONSTANT, 1, OFF(178,438), NUM(178,438) } }, /* 178 */ + { "mn-cn", { FC_REF_CONSTANT, 1, OFF(179,439), NUM(179,439) } }, /* 179 */ + { "mn-mn", { FC_REF_CONSTANT, 1, OFF(180,440), NUM(180,440) } }, /* 180 */ + { "mni", { FC_REF_CONSTANT, 2, OFF(181,441), NUM(181,441) } }, /* 181 */ + { "mnw", { FC_REF_CONSTANT, 1, OFF(182,443), NUM(182,443) } }, /* 182 */ + { "mo", { FC_REF_CONSTANT, 4, OFF(183,444), NUM(183,444) } }, /* 183 */ + { "mr", { FC_REF_CONSTANT, 1, OFF(184,21), NUM(184,21) } }, /* 184 */ + { "mro", { FC_REF_CONSTANT, 1, OFF(185,448), NUM(185,448) } }, /* 185 */ + { "ms", { FC_REF_CONSTANT, 1, OFF(186,38), NUM(186,38) } }, /* 186 */ + { "mt", { FC_REF_CONSTANT, 2, OFF(187,449), NUM(187,449) } }, /* 187 */ + { "my", { FC_REF_CONSTANT, 1, OFF(188,443), NUM(188,443) } }, /* 188 */ + { "na", { FC_REF_CONSTANT, 2, OFF(189,451), NUM(189,451) } }, /* 189 */ + { "nan", { FC_REF_CONSTANT, 84, OFF(190,453), NUM(190,453) } }, /* 190 */ + { "nb", { FC_REF_CONSTANT, 1, OFF(191,537), NUM(191,537) } }, /* 191 */ + { "nds", { FC_REF_CONSTANT, 1, OFF(192,171), NUM(192,171) } }, /* 192 */ + { "ne", { FC_REF_CONSTANT, 1, OFF(193,538), NUM(193,538) } }, /* 193 */ + { "ng", { FC_REF_CONSTANT, 1, OFF(194,38), NUM(194,38) } }, /* 194 */ + { "nhn", { FC_REF_CONSTANT, 2, OFF(195,539), NUM(195,539) } }, /* 195 */ + { "niu", { FC_REF_CONSTANT, 2, OFF(196,541), NUM(196,541) } }, /* 196 */ + { "nl", { FC_REF_CONSTANT, 1, OFF(197,543), NUM(197,543) } }, /* 197 */ + { "nn", { FC_REF_CONSTANT, 1, OFF(198,544), NUM(198,544) } }, /* 198 */ + { "nnp", { FC_REF_CONSTANT, 1, OFF(199,545), NUM(199,545) } }, /* 199 */ + { "no", { FC_REF_CONSTANT, 1, OFF(200,537), NUM(200,537) } }, /* 200 */ + { "nqo", { FC_REF_CONSTANT, 1, OFF(201,546), NUM(201,546) } }, /* 201 */ + { "nr", { FC_REF_CONSTANT, 1, OFF(202,38), NUM(202,38) } }, /* 202 */ + { "nso", { FC_REF_CONSTANT, 2, OFF(203,547), NUM(203,547) } }, /* 203 */ + { "nv", { FC_REF_CONSTANT, 4, OFF(204,549), NUM(204,549) } }, /* 204 */ + { "ny", { FC_REF_CONSTANT, 2, OFF(205,553), NUM(205,553) } }, /* 205 */ + { "oc", { FC_REF_CONSTANT, 1, OFF(206,555), NUM(206,555) } }, /* 206 */ + { "om", { FC_REF_CONSTANT, 1, OFF(207,38), NUM(207,38) } }, /* 207 */ + { "or", { FC_REF_CONSTANT, 1, OFF(208,556), NUM(208,556) } }, /* 208 */ + { "os", { FC_REF_CONSTANT, 1, OFF(209,401), NUM(209,401) } }, /* 209 */ + { "osa", { FC_REF_CONSTANT, 1, OFF(210,557), NUM(210,557) } }, /* 210 */ + { "ota", { FC_REF_CONSTANT, 1, OFF(211,558), NUM(211,558) } }, /* 211 */ + { "otk", { FC_REF_CONSTANT, 1, OFF(212,559), NUM(212,559) } }, /* 212 */ + { "oui", { FC_REF_CONSTANT, 1, OFF(213,560), NUM(213,560) } }, /* 213 */ + { "pa", { FC_REF_CONSTANT, 1, OFF(214,561), NUM(214,561) } }, /* 214 */ + { "pa-pk", { FC_REF_CONSTANT, 1, OFF(215,409), NUM(215,409) } }, /* 215 */ + { "pal", { FC_REF_CONSTANT, 1, OFF(216,562), NUM(216,562) } }, /* 216 */ + { "pap-an", { FC_REF_CONSTANT, 1, OFF(217,563), NUM(217,563) } }, /* 217 */ + { "pap-aw", { FC_REF_CONSTANT, 1, OFF(218,564), NUM(218,564) } }, /* 218 */ + { "peo", { FC_REF_CONSTANT, 1, OFF(219,565), NUM(219,565) } }, /* 219 */ + { "pgd", { FC_REF_CONSTANT, 1, OFF(220,566), NUM(220,566) } }, /* 220 */ + { "pgl", { FC_REF_CONSTANT, 1, OFF(221,567), NUM(221,567) } }, /* 221 */ + { "phn", { FC_REF_CONSTANT, 1, OFF(222,568), NUM(222,568) } }, /* 222 */ + { "pl", { FC_REF_CONSTANT, 2, OFF(223,569), NUM(223,569) } }, /* 223 */ + { "ps-af", { FC_REF_CONSTANT, 1, OFF(224,571), NUM(224,571) } }, /* 224 */ + { "ps-pk", { FC_REF_CONSTANT, 1, OFF(225,572), NUM(225,572) } }, /* 225 */ + { "pt", { FC_REF_CONSTANT, 1, OFF(226,573), NUM(226,573) } }, /* 226 */ + { "qu", { FC_REF_CONSTANT, 2, OFF(227,574), NUM(227,574) } }, /* 227 */ + { "quz", { FC_REF_CONSTANT, 2, OFF(228,574), NUM(228,574) } }, /* 228 */ + { "raj", { FC_REF_CONSTANT, 1, OFF(229,21), NUM(229,21) } }, /* 229 */ + { "rhg", { FC_REF_CONSTANT, 1, OFF(230,576), NUM(230,576) } }, /* 230 */ + { "rif", { FC_REF_CONSTANT, 4, OFF(231,577), NUM(231,577) } }, /* 231 */ + { "rm", { FC_REF_CONSTANT, 1, OFF(232,581), NUM(232,581) } }, /* 232 */ + { "rn", { FC_REF_CONSTANT, 1, OFF(233,38), NUM(233,38) } }, /* 233 */ + { "ro", { FC_REF_CONSTANT, 3, OFF(234,582), NUM(234,582) } }, /* 234 */ + { "ru", { FC_REF_CONSTANT, 1, OFF(235,401), NUM(235,401) } }, /* 235 */ + { "rw", { FC_REF_CONSTANT, 1, OFF(236,38), NUM(236,38) } }, /* 236 */ + { "sa", { FC_REF_CONSTANT, 1, OFF(237,21), NUM(237,21) } }, /* 237 */ + { "sah", { FC_REF_CONSTANT, 1, OFF(238,585), NUM(238,585) } }, /* 238 */ + { "sam", { FC_REF_CONSTANT, 1, OFF(239,586), NUM(239,586) } }, /* 239 */ + { "sat", { FC_REF_CONSTANT, 1, OFF(240,587), NUM(240,587) } }, /* 240 */ + { "sc", { FC_REF_CONSTANT, 1, OFF(241,588), NUM(241,588) } }, /* 241 */ + { "sco", { FC_REF_CONSTANT, 3, OFF(242,589), NUM(242,589) } }, /* 242 */ + { "sd", { FC_REF_CONSTANT, 1, OFF(243,592), NUM(243,592) } }, /* 243 */ + { "se", { FC_REF_CONSTANT, 2, OFF(244,593), NUM(244,593) } }, /* 244 */ + { "sel", { FC_REF_CONSTANT, 1, OFF(245,401), NUM(245,401) } }, /* 245 */ + { "sg", { FC_REF_CONSTANT, 1, OFF(246,595), NUM(246,595) } }, /* 246 */ + { "sgs", { FC_REF_CONSTANT, 3, OFF(247,596), NUM(247,596) } }, /* 247 */ + { "sh", { FC_REF_CONSTANT, 3, OFF(248,599), NUM(248,599) } }, /* 248 */ + { "shn", { FC_REF_CONSTANT, 1, OFF(249,443), NUM(249,443) } }, /* 249 */ + { "shs", { FC_REF_CONSTANT, 2, OFF(250,602), NUM(250,602) } }, /* 250 */ + { "si", { FC_REF_CONSTANT, 1, OFF(251,604), NUM(251,604) } }, /* 251 */ + { "sid", { FC_REF_CONSTANT, 2, OFF(252,605), NUM(252,605) } }, /* 252 */ + { "sk", { FC_REF_CONSTANT, 2, OFF(253,607), NUM(253,607) } }, /* 253 */ + { "sl", { FC_REF_CONSTANT, 2, OFF(254,58), NUM(254,58) } }, /* 254 */ + { "sm", { FC_REF_CONSTANT, 2, OFF(255,609), NUM(255,609) } }, /* 255 */ + { "sma", { FC_REF_CONSTANT, 1, OFF(256,611), NUM(256,611) } }, /* 256 */ + { "smj", { FC_REF_CONSTANT, 1, OFF(257,612), NUM(257,612) } }, /* 257 */ + { "smn", { FC_REF_CONSTANT, 2, OFF(258,613), NUM(258,613) } }, /* 258 */ + { "sms", { FC_REF_CONSTANT, 3, OFF(259,615), NUM(259,615) } }, /* 259 */ + { "sn", { FC_REF_CONSTANT, 1, OFF(260,38), NUM(260,38) } }, /* 260 */ + { "so", { FC_REF_CONSTANT, 1, OFF(261,618), NUM(261,618) } }, /* 261 */ + { "sog", { FC_REF_CONSTANT, 1, OFF(262,619), NUM(262,619) } }, /* 262 */ + { "sq", { FC_REF_CONSTANT, 1, OFF(263,620), NUM(263,620) } }, /* 263 */ + { "sr", { FC_REF_CONSTANT, 1, OFF(264,621), NUM(264,621) } }, /* 264 */ + { "ss", { FC_REF_CONSTANT, 1, OFF(265,38), NUM(265,38) } }, /* 265 */ + { "st", { FC_REF_CONSTANT, 1, OFF(266,38), NUM(266,38) } }, /* 266 */ + { "su", { FC_REF_CONSTANT, 2, OFF(267,622), NUM(267,622) } }, /* 267 */ + { "sux", { FC_REF_CONSTANT, 6, OFF(268,12), NUM(268,12) } }, /* 268 */ + { "suz", { FC_REF_CONSTANT, 1, OFF(269,624), NUM(269,624) } }, /* 269 */ + { "sv", { FC_REF_CONSTANT, 1, OFF(270,625), NUM(270,625) } }, /* 270 */ + { "sw", { FC_REF_CONSTANT, 1, OFF(271,38), NUM(271,38) } }, /* 271 */ + { "syr", { FC_REF_CONSTANT, 1, OFF(272,626), NUM(272,626) } }, /* 272 */ + { "szl", { FC_REF_CONSTANT, 2, OFF(273,627), NUM(273,627) } }, /* 273 */ + { "ta", { FC_REF_CONSTANT, 1, OFF(274,629), NUM(274,629) } }, /* 274 */ + { "tbw", { FC_REF_CONSTANT, 1, OFF(275,630), NUM(275,630) } }, /* 275 */ + { "tcy", { FC_REF_CONSTANT, 1, OFF(276,347), NUM(276,347) } }, /* 276 */ + { "tdd", { FC_REF_CONSTANT, 1, OFF(277,631), NUM(277,631) } }, /* 277 */ + { "te", { FC_REF_CONSTANT, 1, OFF(278,632), NUM(278,632) } }, /* 278 */ + { "tg", { FC_REF_CONSTANT, 1, OFF(279,633), NUM(279,633) } }, /* 279 */ + { "th", { FC_REF_CONSTANT, 1, OFF(280,634), NUM(280,634) } }, /* 280 */ + { "the", { FC_REF_CONSTANT, 1, OFF(281,21), NUM(281,21) } }, /* 281 */ + { "ti-er", { FC_REF_CONSTANT, 2, OFF(282,61), NUM(282,61) } }, /* 282 */ + { "ti-et", { FC_REF_CONSTANT, 2, OFF(283,605), NUM(283,605) } }, /* 283 */ + { "tig", { FC_REF_CONSTANT, 2, OFF(284,635), NUM(284,635) } }, /* 284 */ + { "tk", { FC_REF_CONSTANT, 2, OFF(285,637), NUM(285,637) } }, /* 285 */ + { "tl", { FC_REF_CONSTANT, 1, OFF(286,639), NUM(286,639) } }, /* 286 */ + { "tn", { FC_REF_CONSTANT, 2, OFF(287,547), NUM(287,547) } }, /* 287 */ + { "to", { FC_REF_CONSTANT, 2, OFF(288,609), NUM(288,609) } }, /* 288 */ + { "tpi", { FC_REF_CONSTANT, 1, OFF(289,187), NUM(289,187) } }, /* 289 */ + { "tr", { FC_REF_CONSTANT, 2, OFF(290,640), NUM(290,640) } }, /* 290 */ + { "ts", { FC_REF_CONSTANT, 1, OFF(291,38), NUM(291,38) } }, /* 291 */ + { "tt", { FC_REF_CONSTANT, 1, OFF(292,642), NUM(292,642) } }, /* 292 */ + { "tw", { FC_REF_CONSTANT, 5, OFF(293,7), NUM(293,7) } }, /* 293 */ + { "txg", { FC_REF_CONSTANT, 28, OFF(294,643), NUM(294,643) } }, /* 294 */ + { "ty", { FC_REF_CONSTANT, 3, OFF(295,671), NUM(295,671) } }, /* 295 */ + { "tyv", { FC_REF_CONSTANT, 1, OFF(296,406), NUM(296,406) } }, /* 296 */ + { "ug", { FC_REF_CONSTANT, 1, OFF(297,674), NUM(297,674) } }, /* 297 */ + { "uga", { FC_REF_CONSTANT, 1, OFF(298,675), NUM(298,675) } }, /* 298 */ + { "uk", { FC_REF_CONSTANT, 1, OFF(299,676), NUM(299,676) } }, /* 299 */ + { "und-zmth", { FC_REF_CONSTANT, 12, OFF(300,677), NUM(300,677) } }, /* 300 */ + { "und-zsye", { FC_REF_CONSTANT, 12, OFF(301,689), NUM(301,689) } }, /* 301 */ + { "unm", { FC_REF_CONSTANT, 1, OFF(302,187), NUM(302,187) } }, /* 302 */ + { "ur", { FC_REF_CONSTANT, 1, OFF(303,409), NUM(303,409) } }, /* 303 */ + { "uz", { FC_REF_CONSTANT, 1, OFF(304,38), NUM(304,38) } }, /* 304 */ + { "vai", { FC_REF_CONSTANT, 2, OFF(305,701), NUM(305,701) } }, /* 305 */ + { "ve", { FC_REF_CONSTANT, 2, OFF(306,703), NUM(306,703) } }, /* 306 */ + { "vi", { FC_REF_CONSTANT, 4, OFF(307,705), NUM(307,705) } }, /* 307 */ + { "vo", { FC_REF_CONSTANT, 1, OFF(308,709), NUM(308,709) } }, /* 308 */ + { "vot", { FC_REF_CONSTANT, 2, OFF(309,710), NUM(309,710) } }, /* 309 */ + { "wa", { FC_REF_CONSTANT, 1, OFF(310,712), NUM(310,712) } }, /* 310 */ + { "wae", { FC_REF_CONSTANT, 1, OFF(311,171), NUM(311,171) } }, /* 311 */ + { "wal", { FC_REF_CONSTANT, 2, OFF(312,605), NUM(312,605) } }, /* 312 */ + { "wen", { FC_REF_CONSTANT, 2, OFF(313,713), NUM(313,713) } }, /* 313 */ + { "wo", { FC_REF_CONSTANT, 2, OFF(314,715), NUM(314,715) } }, /* 314 */ + { "xag", { FC_REF_CONSTANT, 1, OFF(315,717), NUM(315,717) } }, /* 315 */ + { "xco", { FC_REF_CONSTANT, 1, OFF(316,718), NUM(316,718) } }, /* 316 */ + { "xcr", { FC_REF_CONSTANT, 1, OFF(317,719), NUM(317,719) } }, /* 317 */ + { "xh", { FC_REF_CONSTANT, 1, OFF(318,38), NUM(318,38) } }, /* 318 */ + { "xlc", { FC_REF_CONSTANT, 1, OFF(319,720), NUM(319,720) } }, /* 319 */ + { "xld", { FC_REF_CONSTANT, 1, OFF(320,721), NUM(320,721) } }, /* 320 */ + { "xmr", { FC_REF_CONSTANT, 1, OFF(321,722), NUM(321,722) } }, /* 321 */ + { "xna", { FC_REF_CONSTANT, 1, OFF(322,723), NUM(322,723) } }, /* 322 */ + { "xpr", { FC_REF_CONSTANT, 1, OFF(323,724), NUM(323,724) } }, /* 323 */ + { "xsa", { FC_REF_CONSTANT, 1, OFF(324,725), NUM(324,725) } }, /* 324 */ + { "xzh", { FC_REF_CONSTANT, 1, OFF(325,726), NUM(325,726) } }, /* 325 */ + { "yap", { FC_REF_CONSTANT, 1, OFF(326,727), NUM(326,727) } }, /* 326 */ + { "yi", { FC_REF_CONSTANT, 1, OFF(327,222), NUM(327,222) } }, /* 327 */ + { "yo", { FC_REF_CONSTANT, 4, OFF(328,728), NUM(328,728) } }, /* 328 */ + { "yue", { FC_REF_CONSTANT, 171, OFF(329,732), NUM(329,732) } }, /* 329 */ + { "yuw", { FC_REF_CONSTANT, 1, OFF(330,187), NUM(330,187) } }, /* 330 */ + { "za", { FC_REF_CONSTANT, 1, OFF(331,38), NUM(331,38) } }, /* 331 */ + { "zh-cn", { FC_REF_CONSTANT, 82, OFF(332,903), NUM(332,903) } }, /* 332 */ + { "zh-hk", { FC_REF_CONSTANT, 171, OFF(333,732), NUM(333,732) } }, /* 333 */ + { "zh-mo", { FC_REF_CONSTANT, 171, OFF(334,732), NUM(334,732) } }, /* 334 */ + { "zh-sg", { FC_REF_CONSTANT, 82, OFF(335,903), NUM(335,903) } }, /* 335 */ + { "zh-tw", { FC_REF_CONSTANT, 83, OFF(336,71), NUM(336,71) } }, /* 336 */ + { "zkt", { FC_REF_CONSTANT, 2, OFF(337,985), NUM(337,985) } }, /* 337 */ + { "zu", { FC_REF_CONSTANT, 1, OFF(338,38), NUM(338,38) } }, /* 338 */ +}, +{ + { { /* 0 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x08104404, 0x08104404, + } }, + { { /* 1 */ + 0xffff8002, 0xffffffff, 0x8002ffff, 0x00000000, + 0xc0000000, 0xf0fc33c0, 0x03000000, 0x00000003, + } }, + { { /* 2 */ + 0xffffffff, 0xfe3fffff, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 3 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x0810cf00, 0x0810cf00, + } }, + { { /* 4 */ + 0x00000000, 0x00000000, 0x00000200, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 5 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00000000, 0x04000000, + } }, + { { /* 6 */ + 0xe7ffffff, 0xffff0fff, 0x0000007f, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 7 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00220008, 0x00220008, + } }, + { { /* 8 */ + 0x00000000, 0x00000300, 0x00000000, 0x00000300, + 0x00010040, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 9 */ + 0x00000000, 0x00000000, 0x08100000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 10 */ + 0x00000048, 0x00000200, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 11 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x30000000, 0x00000000, 0x03000000, + } }, + { { /* 12 */ + 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, + 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, + } }, + { { /* 13 */ + 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, + 0x03ffffff, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 14 */ + 0xffffffff, 0xffffffff, 0xffffffff, 0x001f7fff, + 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, + } }, + { { /* 15 */ + 0xffffffff, 0xffffffff, 0x0000000f, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 16 */ + 0xff7fff7f, 0xff01ff7f, 0x00003d7f, 0xffff7fff, + 0xffff3d7f, 0x003d7fff, 0xff7f7f00, 0x00ff7fff, + } }, + { { /* 17 */ + 0x003d7fff, 0xffffffff, 0x007fff7f, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 18 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x140a2202, 0x140a2202, + } }, + { { /* 19 */ + 0xffffffe0, 0x83ffffff, 0x00003fff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 20 */ + 0x00000000, 0x07fffffe, 0x000007fe, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 21 */ + 0x00000000, 0x00000000, 0xffbfffff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 22 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xfff99fee, 0xd3c4fdff, 0xb000399f, 0x00030000, + } }, + { { /* 23 */ + 0x00000000, 0x00c00030, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 24 */ + 0xffff0042, 0xffffffff, 0x0002ffff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 25 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x10028010, 0x10028010, + } }, + { { /* 26 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00000000, 0x10028010, + } }, + { { /* 27 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x10400080, 0x10400080, + } }, + { { /* 28 */ + 0xc0000000, 0x00030000, 0xc0000000, 0x00000000, + 0x00008000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 29 */ + 0x00000000, 0x00000000, 0x02000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 30 */ + 0x00000000, 0x07ffffde, 0x001009f6, 0x40000000, + 0x01000040, 0x00008200, 0x00001000, 0x00000000, + } }, + { { /* 31 */ + 0xffff0000, 0xffffffff, 0x0000ffff, 0x00000000, + 0x030c0000, 0x0c00cc0f, 0x03000000, 0x00000300, + } }, + { { /* 32 */ + 0xffffffff, 0xffffffff, 0xffff0fff, 0x1fffffff, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 33 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0xffffffff, 0xffffffff, 0x00ffffff, + } }, + { { /* 34 */ + 0xffff4040, 0xffffffff, 0x4040ffff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 35 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 36 */ + 0x00003000, 0x00000000, 0x00000000, 0x00000000, + 0x00110000, 0x00000000, 0x00000000, 0x000000c0, + } }, + { { /* 37 */ + 0x00000000, 0x00000000, 0x08000000, 0x00000008, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 38 */ + 0x00003000, 0x00000030, 0x00000000, 0x0000300c, + 0x000c0000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 39 */ + 0x00000000, 0x3a8b0000, 0x9e78e6b9, 0x0000802e, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 40 */ + 0xffff0000, 0xffffd7ff, 0x0000d7ff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 41 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x10008200, 0x10008200, + } }, + { { /* 42 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x060c3303, 0x060c3303, + } }, + { { /* 43 */ + 0x00000003, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 44 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x03000000, 0x00003000, 0x00000000, + } }, + { { /* 45 */ + 0x00000000, 0x00000000, 0x000fffff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 46 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xffffffff, 0xffffffff, 0xf8000007, 0x00000000, + } }, + { { /* 47 */ + 0x00000000, 0x00000000, 0x00000c00, 0x00000000, + 0x20010040, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 48 */ + 0x00000000, 0x00000000, 0x08100000, 0x00040000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 49 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xfff99fee, 0xd3c5fdff, 0xb000399f, 0x00000000, + } }, + { { /* 50 */ + 0x00000000, 0x00000000, 0xfffffeff, 0x3d7e03ff, + 0xfeff0003, 0x03ffffff, 0x00000000, 0x00000000, + } }, + { { /* 51 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x12120404, 0x12120404, + } }, + { { /* 52 */ + 0xfff99fee, 0xf3e5fdff, 0x0007399f, 0x0001ffff, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 53 */ + 0x000330c0, 0x00000000, 0x00000000, 0x60000003, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 54 */ + 0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000, + 0x00000000, 0x0c00c000, 0x00000000, 0x00000000, + } }, + { { /* 55 */ + 0xff7fff7f, 0xff01ff00, 0x3d7f3d7f, 0xffff7fff, + 0xffff0000, 0x003d7fff, 0xff7f7f3d, 0x00ff7fff, + } }, + { { /* 56 */ + 0x003d7fff, 0xffffffff, 0x007fff00, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 57 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x140ca381, 0x140ca381, + } }, + { { /* 58 */ + 0x00000000, 0x80000000, 0x00000001, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 59 */ + 0xffffffff, 0xffdfffff, 0x000000ff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 60 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x10020004, 0x10020004, + } }, + { { /* 61 */ + 0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000, + 0x00000000, 0x00000030, 0x000c0000, 0x030300c0, + } }, + { { /* 62 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0xffffffff, 0xffffffff, 0x001fffff, + } }, + { { /* 63 */ + 0xffffffff, 0x007fffff, 0xf3ff3fff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 64 */ + 0x00000000, 0x061ef5c0, 0x000001f6, 0x40000000, + 0x01040040, 0x00208210, 0x00005040, 0x00000000, + } }, + { { /* 65 */ + 0xc373ff8b, 0x1b0f6840, 0xf34ce9ac, 0xc0080200, + 0xca3e795c, 0x06487976, 0xf7f02fdf, 0xa8ff033a, + } }, + { { /* 66 */ + 0x233fef37, 0xfd59b004, 0xfffff3ca, 0xfff9de9f, + 0x7df7abff, 0x8eecc000, 0xffdbeebf, 0x45fad003, + } }, + { { /* 67 */ + 0xdffefae1, 0x10abbfef, 0xfcaaffeb, 0x24fdef3f, + 0x7f7678ad, 0xedfff00c, 0x2cfacff6, 0xeb6bf7f9, + } }, + { { /* 68 */ + 0x95bf1ffd, 0xbfbf6677, 0xfeb43bfb, 0x11e27bae, + 0x41bea681, 0x72c31435, 0x71917d70, 0x276b0003, + } }, + { { /* 69 */ + 0x70cf57cb, 0x0def4732, 0xfc747eda, 0xbdb4fe06, + 0x8bca3f9f, 0x58007e49, 0xebec228f, 0xddbb8a5c, + } }, + { { /* 70 */ + 0xb6e7ef60, 0xf293a40f, 0x549e37bb, 0x9bafd04b, + 0xf7d4c414, 0x0a1430b0, 0x88d02f08, 0x192fff7e, + } }, + { { /* 71 */ + 0xfb07ffda, 0x7beb7ff1, 0x0010c5ef, 0xfdff99ff, + 0x056779d7, 0xfdcbffe7, 0x4040c3ff, 0xbd8e6ff7, + } }, + { { /* 72 */ + 0x0497dffa, 0x5bfff4c0, 0xd0e7ed7b, 0xf8e0047e, + 0xb73eff9f, 0x882e7dfe, 0xbe7ffffd, 0xf6c483fe, + } }, + { { /* 73 */ + 0xb8fdf357, 0xef7dd680, 0x47885767, 0xc3dfff7d, + 0x37a9f0ff, 0x70fc7de0, 0xec9a3f6f, 0x86814cb3, + } }, + { { /* 74 */ + 0xdd5c3f9e, 0x4819f70d, 0x0007fea3, 0x38ffaf56, + 0xefb8980d, 0xb760403d, 0x9035d8ce, 0x3fff72bf, + } }, + { { /* 75 */ + 0x7a117ff7, 0xabfff7bb, 0x6fbeff00, 0xfe72a93c, + 0xf11bcfef, 0xf40adb6b, 0xef7ec3e6, 0xf6109b9c, + } }, + { { /* 76 */ + 0x16f4f048, 0x5182feb5, 0x15bbc7b1, 0xfbdf6e87, + 0x63cde43f, 0x7e7ec1ff, 0x7d5ffdeb, 0xfcfe777b, + } }, + { { /* 77 */ + 0xdbea960b, 0x53e86229, 0xfdef37df, 0xbd8136f5, + 0xfcbddc18, 0xffffd2e4, 0xffe03fd7, 0xabf87f6f, + } }, + { { /* 78 */ + 0x6ed99bae, 0xf115f5fb, 0xbdfb79a9, 0xadaf5a3c, + 0x1facdbba, 0x837971fc, 0xc35f7cf7, 0x0567dfff, + } }, + { { /* 79 */ + 0x8467ff9a, 0xdf8b1534, 0x3373f9f3, 0x5e1af7bd, + 0xa03fbf40, 0x01ebffff, 0xcfdddfc0, 0xabd37500, + } }, + { { /* 80 */ + 0xeed6f8c3, 0xb7ff43fd, 0x42275eaf, 0xf6869bac, + 0xf6bc27d7, 0x35b7f787, 0xe176aacd, 0xe29f49e7, + } }, + { { /* 81 */ + 0xaff2545c, 0x61d82b3f, 0xbbb8fc3b, 0x7b7dffcf, + 0x1ce0bf95, 0x43ff7dfd, 0xfffe5ff6, 0xc4ced3ef, + } }, + { { /* 82 */ + 0xadbc8db6, 0x11eb63dc, 0x23d0df59, 0xf3dbbeb4, + 0xdbc71fe7, 0xfae4ff63, 0x63f7b22b, 0xadbaed3b, + } }, + { { /* 83 */ + 0x7efffe01, 0x02bcfff7, 0xef3932ff, 0x8005fffc, + 0xbcf577fb, 0xfff7010d, 0xbf3afffb, 0xdfff0057, + } }, + { { /* 84 */ + 0xbd7def7b, 0xc8d4db88, 0xed7cfff3, 0x56ff5dee, + 0xac5f7e0d, 0xd57fff96, 0xc1403fee, 0xffe76ff9, + } }, + { { /* 85 */ + 0x8e77779b, 0xe45d6ebf, 0x5f1f6fcf, 0xfedfe07f, + 0x01fed7db, 0xfb7bff00, 0x1fdfffd4, 0xfffff800, + } }, + { { /* 86 */ + 0x007bfb8f, 0x7f5cbf00, 0x07f3ffff, 0x3de7eba0, + 0xfbd7f7bf, 0x6003ffbf, 0xbfedfffd, 0x027fefbb, + } }, + { { /* 87 */ + 0xddfdfe40, 0xe2f9fdff, 0xfb1f680b, 0xaffdfbe3, + 0xf7ed9fa4, 0xf80f7a7d, 0x0fd5eebe, 0xfd9fbb5d, + } }, + { { /* 88 */ + 0x3bf9f2db, 0xebccfe7f, 0x73fa876a, 0x9ffc95fc, + 0xfaf7109f, 0xbbcdddb7, 0xeccdf87e, 0x3c3ff366, + } }, + { { /* 89 */ + 0xb03ffffd, 0x067ee9f7, 0xfe0696ae, 0x5fd7d576, + 0xa3f33fd1, 0x6fb7cf07, 0x7f449fd1, 0xd3dd7b59, + } }, + { { /* 90 */ + 0xa9bdaf3b, 0xff3a7dcf, 0xf6ebfbe0, 0xffffb401, + 0xb7bf7afa, 0x0ffdc000, 0xff1fff7f, 0x95fffefc, + } }, + { { /* 91 */ + 0xb5dc0000, 0x3f3eef63, 0x001bfb7f, 0xfbf6e800, + 0xb8df9eef, 0x003fff9f, 0xf5ff7bd0, 0x3fffdfdb, + } }, + { { /* 92 */ + 0x00bffdf0, 0xbbbd8420, 0xffdedf37, 0x0ff3ff6d, + 0x5efb604c, 0xfafbfffb, 0x0219fe5e, 0xf9de79f4, + } }, + { { /* 93 */ + 0xebfaa7f7, 0xff3401eb, 0xef73ebd3, 0xc040afd7, + 0xdcff72bb, 0x2fd8f17f, 0xfe0bb8ec, 0x1f0bdda3, + } }, + { { /* 94 */ + 0x47cf8f1d, 0xffdeb12b, 0xda737fee, 0xcbc424ff, + 0xcbf2f75d, 0xb4edecfd, 0x4dddbff9, 0xfb8d99dd, + } }, + { { /* 95 */ + 0xaf7bbb7f, 0xc959ddfb, 0xfab5fc4f, 0x6d5fafe3, + 0x3f7dffff, 0xffdb7800, 0x7effb6ff, 0x022ffbaf, + } }, + { { /* 96 */ + 0xefc7ff9b, 0xffffffa5, 0xc7000007, 0xfff1f7ff, + 0x01bf7ffd, 0xfdbcdc00, 0xffffbff5, 0x3effff7f, + } }, + { { /* 97 */ + 0xbe000029, 0xff7ff9ff, 0xfd7e6efb, 0x039ecbff, + 0xfbdde300, 0xf6dfccff, 0x117fffff, 0xfbf6f800, + } }, + { { /* 98 */ + 0xd73ce7ef, 0xdfeffeef, 0xedbfc00b, 0xfdcdfedf, + 0x40fd7bf5, 0xb75fffff, 0xf930ffdf, 0xdc97fbdf, + } }, + { { /* 99 */ + 0xbff2fef3, 0xdfbf8fdf, 0xede6177f, 0x35530f7f, + 0x877e447c, 0x45bbfa12, 0x779eede0, 0xbfd98017, + } }, + { { /* 100 */ + 0xde897e55, 0x0447c16f, 0xf75d7ade, 0x290557ff, + 0xfe9586f7, 0xf32f97b3, 0x9f75cfff, 0xfb1771f7, + } }, + { { /* 101 */ + 0xee1934ee, 0xef6137cc, 0xef4c9fd6, 0xfbddd68f, + 0x6def7b73, 0xa431d7fe, 0x97d75e7f, 0xffd80f5b, + } }, + { { /* 102 */ + 0x7bce9d83, 0xdcff22ec, 0xef87763d, 0xfdeddfe7, + 0xa0fc4fff, 0xdbfc3b77, 0x7fdc3ded, 0xf5706fa9, + } }, + { { /* 103 */ + 0x2c403ffb, 0x847fff7f, 0xdeb7ec57, 0xf22fe69c, + 0xd5b50feb, 0xede7afeb, 0xfff08c2f, 0xe8f0537f, + } }, + { { /* 104 */ + 0xb5ffb99d, 0xe78fff66, 0xbe10d981, 0xe3c19c7c, + 0x27339cd1, 0xff6d0cbc, 0xefb7fcb7, 0xffffa0df, + } }, + { { /* 105 */ + 0xfe7bbf0b, 0x353fa3ff, 0x97cd13cc, 0xfb277637, + 0x7e6ccfd6, 0xed31ec50, 0xfc1c677c, 0x5fbff6fa, + } }, + { { /* 106 */ + 0xae2f0fba, 0x7ffea3ad, 0xde74fcf0, 0xf200ffef, + 0xfea2fbbf, 0xbcff3daf, 0x5fb9f694, 0x3f8ff3ad, + } }, + { { /* 107 */ + 0xa01ff26c, 0x01bfffef, 0x70057728, 0xda03ff35, + 0xc7fad2f9, 0x5c1d3fbf, 0xec33ff3a, 0xfe9cb7af, + } }, + { { /* 108 */ + 0x7a9f5236, 0xe722bffa, 0xfcff9ff7, 0xb61d2fbb, + 0x1dfded06, 0xefdf7dd7, 0xf166eb23, 0x0dc07ed9, + } }, + { { /* 109 */ + 0xdfbf3d3d, 0xba83c945, 0x9dd07dd1, 0xcf737b87, + 0xc3f59ff3, 0xc5fedf0d, 0x83020cb3, 0xaec0e879, + } }, + { { /* 110 */ + 0x6f0fc773, 0x093ffd7d, 0x0157fff1, 0x01ff62fb, + 0x3bf3fdb4, 0x43b2b013, 0xff305ed3, 0xeb9f0fff, + } }, + { { /* 111 */ + 0xf203feef, 0xfb893fef, 0x9e9937a9, 0xa72cdef9, + 0xc1f63733, 0xfe3e812e, 0xf2f75d20, 0x69d7d585, + } }, + { { /* 112 */ + 0xffffffff, 0xff6fdb07, 0xd97fc4ff, 0xbe0fefce, + 0xf05ef17b, 0xffb7f6cf, 0xef845ef7, 0x0edfd7cb, + } }, + { { /* 113 */ + 0xfcffff08, 0xffffee3f, 0xd7ff13ff, 0x7ffdaf0f, + 0x1ffabdc7, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 114 */ + 0x00000000, 0xe7400000, 0xf933bd38, 0xfeed7feb, + 0x7c767fe8, 0xffefb3f7, 0xd8b7feaf, 0xfbbfff6f, + } }, + { { /* 115 */ + 0xdbf7f8fb, 0xe2f91752, 0x754785c8, 0xe3ef9090, + 0x3f6d9ef4, 0x0536ee2e, 0x7ff3f7bc, 0x7f3fa07b, + } }, + { { /* 116 */ + 0xeb600567, 0x6601babe, 0x583ffcd8, 0x87dfcaf7, + 0xffa0bfcd, 0xfebf5bcd, 0xefa7b6fd, 0xdf9c77ef, + } }, + { { /* 117 */ + 0xf8773fb7, 0xb7fc9d27, 0xdfefcab5, 0xf1b6fb5a, + 0xef1fec39, 0x7ffbfbbf, 0xdafe000d, 0x4e7fbdfb, + } }, + { { /* 118 */ + 0x5ac033ff, 0x9ffebff5, 0x005fffbf, 0xfdf80000, + 0x6ffdffca, 0xa001cffd, 0xfbf2dfff, 0xff7fdfbf, + } }, + { { /* 119 */ + 0x080ffeda, 0xbfffba08, 0xeed77afd, 0x67f9fbeb, + 0xff93e044, 0x9f57df97, 0x08dffef7, 0xfedfdf80, + } }, + { { /* 120 */ + 0xf7feffc5, 0x6803fffb, 0x6bfa67fb, 0x5fe27fff, + 0xff73ffff, 0xe7fb87df, 0xf7a7ebfd, 0xefc7bf7e, + } }, + { { /* 121 */ + 0xdf821ef3, 0xdf7e76ff, 0xda7d79c9, 0x1e9befbe, + 0x77fb7ce0, 0xfffb87be, 0xffdb1bff, 0x4fe03f5c, + } }, + { { /* 122 */ + 0x5f0e7fff, 0xddbf77ff, 0xfffff04f, 0x0ff8ffff, + 0xfddfa3be, 0xfffdfc1c, 0xfb9e1f7d, 0xdedcbdff, + } }, + { { /* 123 */ + 0xbafb3f6f, 0xfbefdf7f, 0x2eec7d1b, 0xf2f7af8e, + 0xcfee7b0f, 0x77c61d96, 0xfff57e07, 0x7fdfd982, + } }, + { { /* 124 */ + 0xc7ff5ee6, 0x79effeee, 0xffcf9a56, 0xde5efe5f, + 0xf9e8896e, 0xe6c4f45e, 0xbe7c0001, 0xdddf3b7f, + } }, + { { /* 125 */ + 0xe9efd59d, 0xde5334ac, 0x4bf7f573, 0x9eff7b4f, + 0x476eb8fe, 0xff450dfb, 0xfbfeabfd, 0xddffe9d7, + } }, + { { /* 126 */ + 0x7fffedf7, 0x7eebddfd, 0xb7ffcfe7, 0xef91bde9, + 0xd77c5d75, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 127 */ + 0x00000000, 0xfa800000, 0xb4f1ffee, 0x2fefbf76, + 0x77bfb677, 0xfffd9fbf, 0xf6ae95bf, 0x7f3b75ff, + } }, + { { /* 128 */ + 0x0af9a7f5, 0x00000000, 0x00000000, 0x2bddfbd0, + 0x9a7ff633, 0xd6fcfdab, 0xbfebf9e6, 0xf41fdfdf, + } }, + { { /* 129 */ + 0xffffa6fd, 0xf37b4aff, 0xfef97fb7, 0x1d5cb6ff, + 0xe5ff7ff6, 0x24041f7b, 0xf99ebe05, 0xdff2dbe3, + } }, + { { /* 130 */ + 0xfdff6fef, 0xcbfcd679, 0xefffebfd, 0x0000001f, + 0x98000000, 0x8017e148, 0x00fe6a74, 0xfdf16d7f, + } }, + { { /* 131 */ + 0xfef3b87f, 0xf176e01f, 0x7b3fee96, 0xfffdeb8d, + 0xcbb3adff, 0xe17f84ef, 0xbff04daa, 0xfe3fbf3f, + } }, + { { /* 132 */ + 0xffd7ebff, 0xcf7fffdf, 0x85edfffb, 0x07bcd73f, + 0xfe0faeff, 0x76bffdaf, 0x37bbfaef, 0xa3ba7fdc, + } }, + { { /* 133 */ + 0x56f7b6ff, 0xe7df60f8, 0x4cdfff61, 0xff45b0fb, + 0x3ffa7ded, 0x18fc1fff, 0xe3afffff, 0xdf83c7d3, + } }, + { { /* 134 */ + 0xef7dfb57, 0x1378efff, 0x5ff7fec0, 0x5ee334bb, + 0xeff6f70d, 0x00bfd7fe, 0xf7f7f59d, 0xffe051de, + } }, + { { /* 135 */ + 0x037ffec9, 0xbfef5f01, 0x60a79ff1, 0xf1ffef1d, + 0x0000000f, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 136 */ + 0x00000000, 0x00000000, 0x00000000, 0x3c800000, + 0xd91ffb4d, 0xfee37b3a, 0xdc7f3fe9, 0x0000003f, + } }, + { { /* 137 */ + 0x50000000, 0xbe07f51f, 0xf91bfc1d, 0x71ffbc1e, + 0x5bbe6ff9, 0x9b1b5796, 0xfffc7fff, 0xafe7872e, + } }, + { { /* 138 */ + 0xf34febf5, 0xe725dffd, 0x5d440bdc, 0xfddd5747, + 0x7790ed3f, 0x8ac87d7f, 0xf3f9fafa, 0xef4b202a, + } }, + { { /* 139 */ + 0x79cff5ff, 0x0ba5abd3, 0xfb8ff77a, 0x001f8ebd, + 0x00000000, 0xfd4ef300, 0x88001a57, 0x7654aeac, + } }, + { { /* 140 */ + 0xcdff17ad, 0xf42fffb2, 0xdbff5baa, 0x00000002, + 0x73c00000, 0x2e3ff9ea, 0xbbfffa8e, 0xffd376bc, + } }, + { { /* 141 */ + 0x7e72eefe, 0xe7f77ebd, 0xcefdf77f, 0x00000ff5, + 0x00000000, 0xdb9ba900, 0x917fa4c7, 0x7ecef8ca, + } }, + { { /* 142 */ + 0xc7e77d7a, 0xdcaecbbd, 0x8f76fd7e, 0x7cf391d3, + 0x4c2f01e5, 0xa360ed77, 0x5ef807db, 0x21811df7, + } }, + { { /* 143 */ + 0x309c6be0, 0xfade3b3a, 0xc3f57f53, 0x07ba61cd, + 0x00000000, 0x00000000, 0x00000000, 0xbefe26e0, + } }, + { { /* 144 */ + 0xebb503f9, 0xe9cbe36d, 0xbfde9c2f, 0xabbf9f83, + 0xffd51ff7, 0xdffeb7df, 0xffeffdae, 0xeffdfb7e, + } }, + { { /* 145 */ + 0x6ebfaaff, 0x00000000, 0x00000000, 0xb6200000, + 0xbe9e7fcd, 0x58f162b3, 0xfd7bf10d, 0xbefde9f1, + } }, + { { /* 146 */ + 0x5f6dc6c3, 0x69ffff3d, 0xfbf4ffcf, 0x4ff7dcfb, + 0x11372000, 0x00000015, 0x00000000, 0x00000000, + } }, + { { /* 147 */ + 0x00003000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 148 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x1a10cfc5, 0x9a10cfc5, + } }, + { { /* 149 */ + 0x00000000, 0x00000000, 0x000c0000, 0x01000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 150 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x0000fffc, + } }, + { { /* 151 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xffffffff, 0xffffffff, 0xffffffff, 0xfe0fffff, + } }, + { { /* 152 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x10420084, 0x10420084, + } }, + { { /* 153 */ + 0xc0000000, 0x00030000, 0xc0000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 154 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x24082202, 0x24082202, + } }, + { { /* 155 */ + 0x0c00f000, 0x00000000, 0x03000180, 0x6000c033, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 156 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x021c0a08, 0x021c0a08, + } }, + { { /* 157 */ + 0x00000030, 0x00000000, 0x0000001e, 0x18000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 158 */ + 0xfdffa966, 0xffffdfff, 0xa965dfff, 0x03ffffff, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 159 */ + 0x0000000c, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 160 */ + 0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000, + 0x00000000, 0x00000c00, 0x00c00000, 0x000c0000, + } }, + { { /* 161 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x0010c604, 0x8010c604, + } }, + { { /* 162 */ + 0x00000000, 0x00000000, 0x00000000, 0x01f00000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 163 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x0000003f, 0x00000000, 0x00000000, 0x000c0000, + } }, + { { /* 164 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x25082262, 0x25082262, + } }, + { { /* 165 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x90400010, 0x10400010, + } }, + { { /* 166 */ + 0x00000000, 0x00000000, 0xffffffff, 0xffffffff, + 0x07ffffff, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 167 */ + 0xfff99fec, 0xf3e5fdff, 0xf807399f, 0x0000ffff, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 168 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xffffffff, 0x0001ffff, 0x00000000, 0x00000000, + } }, + { { /* 169 */ + 0xfffffd3f, 0x91bfffff, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 170 */ + 0x0c000000, 0x00000000, 0x00000c00, 0x00000000, + 0x00170240, 0x00040000, 0x001fe000, 0x00000000, + } }, + { { /* 171 */ + 0x00000000, 0x00000000, 0x08500000, 0x00000008, + 0x00000800, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 172 */ + 0x00001003, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 173 */ + 0xffffffff, 0x0000ffff, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 174 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xffffd740, 0xfffffffb, 0x00007fff, 0x00000000, + } }, + { { /* 175 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00528f81, 0x00528f81, + } }, + { { /* 176 */ + 0x30000300, 0x00300030, 0x30000000, 0x00003000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 177 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x10600010, 0x10600010, + } }, + { { /* 178 */ + 0x00000000, 0x00000000, 0x00000000, 0x60000003, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 179 */ + 0xffffffff, 0x0000e00f, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 180 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x10020000, 0x10020000, + } }, + { { /* 181 */ + 0x00000000, 0x00000000, 0x00000c00, 0x00000000, + 0x20000402, 0x00180000, 0x00000000, 0x00000000, + } }, + { { /* 182 */ + 0x00000000, 0x00000000, 0x00880000, 0x00040000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 183 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00400030, 0x00400030, + } }, + { { /* 184 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x0e1e7707, 0x0e1e7707, + } }, + { { /* 185 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x25092042, 0x25092042, + } }, + { { /* 186 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x02041107, 0x02041107, + } }, + { { /* 187 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x9c508e14, 0x1c508e14, + } }, + { { /* 188 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x04082202, 0x04082202, + } }, + { { /* 189 */ + 0x00000c00, 0x00000003, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 190 */ + 0xc0000c0c, 0x00000000, 0x00c00003, 0x00000c03, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 191 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x020c1383, 0x020c1383, + } }, + { { /* 192 */ + 0xff7fff7f, 0xff01ff7f, 0x00003d7f, 0x00ff00ff, + 0x00ff3d7f, 0x003d7fff, 0xff7f7f00, 0x00ff7f00, + } }, + { { /* 193 */ + 0x003d7f00, 0xffff01ff, 0x007fff7f, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 194 */ + 0xffffefff, 0xb7ffff7f, 0x3fff3fff, 0x00000000, + 0xffffffff, 0xffffffff, 0xffffffff, 0x07ffffff, + } }, + { { /* 195 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x040a2202, 0x042a220a, + } }, + { { /* 196 */ + 0x00000000, 0x00000200, 0x00000000, 0x00000200, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 197 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x20000000, 0x00000000, 0x02000000, + } }, + { { /* 198 */ + 0x00000000, 0xffff0000, 0x000007ff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 199 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xfffbafee, 0xf3edfdff, 0x00013bbf, 0x00000001, + } }, + { { /* 200 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00000080, 0x00000080, + } }, + { { /* 201 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x03000402, 0x00180000, 0x00000000, 0x00000000, + } }, + { { /* 202 */ + 0x00000000, 0x00000000, 0x00880000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 203 */ + 0x000c0003, 0x00000c00, 0x00003000, 0x00000c00, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 204 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x08000000, 0x00000000, 0x00000000, + } }, + { { /* 205 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0xffff0000, 0x000007ff, + } }, + { { /* 206 */ + 0xffffffff, 0xffffffff, 0x0000007f, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 207 */ + 0xffffffff, 0xffffffff, 0xffff87ff, 0xffffffff, + 0xffff80ff, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 208 */ + 0x00000000, 0x007fffff, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 209 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0xffffffff, 0xffffffff, 0x8007ffff, + } }, + { { /* 210 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00080000, 0x00080000, + } }, + { { /* 211 */ + 0x0c0030c0, 0x00000000, 0x0300001e, 0x66000003, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 212 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00040100, 0x00040100, + } }, + { { /* 213 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x14482202, 0x14482202, + } }, + { { /* 214 */ + 0x00000000, 0x00000000, 0x00030000, 0x00030000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 215 */ + 0x00000000, 0xfffe0000, 0x007fffff, 0xfffffffe, + 0x000000ff, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 216 */ + 0x00000000, 0x00008000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 217 */ + 0x000c0000, 0x00000000, 0x00000c00, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 218 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00000200, 0x00000200, + } }, + { { /* 219 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00003c00, 0x00000030, + } }, + { { /* 220 */ + 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, + 0x00001fff, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 221 */ + 0xffff4002, 0xffffffff, 0x4002ffff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 222 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x64092242, 0x64092242, + } }, + { { /* 223 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x060cb301, 0x060cb301, + } }, + { { /* 224 */ + 0x00000c7e, 0x031f8000, 0x0063f200, 0x000df840, + 0x00037e08, 0x08000dfa, 0x0df901bf, 0x5437e400, + } }, + { { /* 225 */ + 0x00000025, 0x40006fc0, 0x27f91be4, 0xdee00000, + 0x007ff83f, 0x00007f7f, 0x00000000, 0x00000000, + } }, + { { /* 226 */ + 0x00000000, 0x00000000, 0x00000000, 0x007f8000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 227 */ + 0x000000a7, 0x00000000, 0xfffffffe, 0xffffffff, + 0x780fffff, 0xfffffffe, 0xffffffff, 0x787fffff, + } }, + { { /* 228 */ + 0x03506f8b, 0x1b042042, 0x62808020, 0x400a0000, + 0x10341b41, 0x04003812, 0x03608c02, 0x08454038, + } }, + { { /* 229 */ + 0x2403c002, 0x15108000, 0x1229e040, 0x80280000, + 0x28002800, 0x8060c002, 0x2080040c, 0x05284002, + } }, + { { /* 230 */ + 0x82042a00, 0x02000818, 0x10008200, 0x20700020, + 0x03022000, 0x40a41000, 0x0420a020, 0x00000080, + } }, + { { /* 231 */ + 0x80040011, 0x00000400, 0x04012b78, 0x11a23920, + 0x02842460, 0x00c01021, 0x20002050, 0x07400042, + } }, + { { /* 232 */ + 0x208205c9, 0x0fc10230, 0x08402480, 0x00258018, + 0x88000080, 0x42120609, 0xa32002a8, 0x40040094, + } }, + { { /* 233 */ + 0x00c00024, 0x8e000001, 0x059e058a, 0x013b0001, + 0x85000010, 0x08080000, 0x02d07d04, 0x018d9838, + } }, + { { /* 234 */ + 0x8803f310, 0x03000840, 0x00000704, 0x30080500, + 0x00001000, 0x20040000, 0x00000003, 0x04040002, + } }, + { { /* 235 */ + 0x000100d0, 0x40028000, 0x00088040, 0x00000000, + 0x34000210, 0x00400e00, 0x00000020, 0x00000008, + } }, + { { /* 236 */ + 0x00000040, 0x00060000, 0x00000000, 0x00100100, + 0x00000080, 0x00000000, 0x4c000000, 0x240d0009, + } }, + { { /* 237 */ + 0x80048000, 0x00010180, 0x00020484, 0x00000400, + 0x00000804, 0x00000008, 0x80004800, 0x16800000, + } }, + { { /* 238 */ + 0x00200065, 0x00120410, 0x44920403, 0x40000200, + 0x10880008, 0x40080100, 0x00001482, 0x00074800, + } }, + { { /* 239 */ + 0x14608200, 0x00024e84, 0x00128380, 0x20184520, + 0x0240041c, 0x0a001120, 0x00180a00, 0x88000800, + } }, + { { /* 240 */ + 0x01000002, 0x00008001, 0x04000040, 0x80000040, + 0x08040000, 0x00000000, 0x00001202, 0x00000002, + } }, + { { /* 241 */ + 0x00000000, 0x00000004, 0x21910000, 0x00000858, + 0xbf8013a0, 0x8279401c, 0xa8041054, 0xc5004282, + } }, + { { /* 242 */ + 0x0402ce56, 0xfc020000, 0x40200d21, 0x00028030, + 0x00010000, 0x01081202, 0x00000000, 0x00410003, + } }, + { { /* 243 */ + 0x00404080, 0x00000200, 0x00010000, 0x00000000, + 0x00000000, 0x00000000, 0x60000000, 0x480241ea, + } }, + { { /* 244 */ + 0x2000104c, 0x2109a820, 0x00200020, 0x7b1c0008, + 0x10a0840a, 0x01c028c0, 0x00000608, 0x04c00000, + } }, + { { /* 245 */ + 0x80398412, 0x40a200e0, 0x02080000, 0x12030a04, + 0x008d1833, 0x02184602, 0x13803028, 0x00200801, + } }, + { { /* 246 */ + 0x20440000, 0x000005a1, 0x00050800, 0x0020a328, + 0x80100000, 0x10040649, 0x10020020, 0x00090180, + } }, + { { /* 247 */ + 0x8c008202, 0x00000000, 0x00205910, 0x0041410c, + 0x00004004, 0x40441290, 0x00010080, 0x01040000, + } }, + { { /* 248 */ + 0x04070000, 0x89108040, 0x00282a81, 0x82420000, + 0x51a20411, 0x32220800, 0x2b0d2220, 0x40c83003, + } }, + { { /* 249 */ + 0x82020082, 0x80008900, 0x10a00200, 0x08004100, + 0x09041108, 0x000405a6, 0x0c018000, 0x04104002, + } }, + { { /* 250 */ + 0x00002000, 0x44003000, 0x01000004, 0x00008200, + 0x00000008, 0x00044010, 0x00002002, 0x00001040, + } }, + { { /* 251 */ + 0x00000000, 0xca008000, 0x02828020, 0x00b1100c, + 0x12824280, 0x22013030, 0x00808820, 0x040013e4, + } }, + { { /* 252 */ + 0x801840c0, 0x1000a1a1, 0x00000004, 0x0050c200, + 0x00c20082, 0x00104840, 0x10400080, 0xa3140000, + } }, + { { /* 253 */ + 0xa8a02301, 0x24123d00, 0x80030200, 0xc0028022, + 0x34a10000, 0x00408005, 0x00190010, 0x882a0000, + } }, + { { /* 254 */ + 0x00080018, 0x33000402, 0x9002010a, 0x00000000, + 0x00800020, 0x00010100, 0x84040810, 0x04004000, + } }, + { { /* 255 */ + 0x10006020, 0x00000000, 0x00000000, 0x30a02000, + 0x00000004, 0x00000000, 0x01000800, 0x20000000, + } }, + { { /* 256 */ + 0x02000000, 0x02000602, 0x80000800, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 257 */ + 0x00000010, 0x44040083, 0x00081000, 0x0818824c, + 0x00400e00, 0x8c300000, 0x08146001, 0x00000000, + } }, + { { /* 258 */ + 0x00828000, 0x41900000, 0x84804006, 0x24010001, + 0x02400108, 0x9b080006, 0x00201602, 0x0009012e, + } }, + { { /* 259 */ + 0x40800800, 0x48000420, 0x10000032, 0x01904440, + 0x02000100, 0x10048000, 0x00020000, 0x08820802, + } }, + { { /* 260 */ + 0x08080ba0, 0x00009242, 0x00400000, 0xc0008080, + 0x20410001, 0x04400000, 0x60020820, 0x00100000, + } }, + { { /* 261 */ + 0x00108046, 0x01001805, 0x90100000, 0x00014010, + 0x00000010, 0x00000000, 0x0000000b, 0x00008800, + } }, + { { /* 262 */ + 0x00000000, 0x00001000, 0x00000000, 0x20018800, + 0x00004600, 0x06002000, 0x00000100, 0x00000000, + } }, + { { /* 263 */ + 0x00000000, 0x10400042, 0x02004000, 0x00004280, + 0x80000400, 0x00020000, 0x00000008, 0x00000020, + } }, + { { /* 264 */ + 0x00000040, 0x20600400, 0x0a000180, 0x02040280, + 0x00000000, 0x00409001, 0x02000004, 0x00003200, + } }, + { { /* 265 */ + 0x88000000, 0x80404800, 0x00000010, 0x00040008, + 0x00000a90, 0x00000200, 0x00002000, 0x40002001, + } }, + { { /* 266 */ + 0x00000048, 0x00100000, 0x00000000, 0x00000001, + 0x00000008, 0x20010080, 0x00000000, 0x00400040, + } }, + { { /* 267 */ + 0x85000000, 0x0c8f0108, 0x32129000, 0x80090420, + 0x00024000, 0x40040800, 0x092000a0, 0x00100204, + } }, + { { /* 268 */ + 0x00002000, 0x00000000, 0x00440004, 0x6c000000, + 0x000000d0, 0x80004000, 0x88800440, 0x41144018, + } }, + { { /* 269 */ + 0x80001a02, 0x14000001, 0x00000001, 0x0000004a, + 0x00000000, 0x00083000, 0x08000000, 0x0008a024, + } }, + { { /* 270 */ + 0x00300004, 0x00140000, 0x20000000, 0x00001800, + 0x00020002, 0x04000000, 0x00000002, 0x00000100, + } }, + { { /* 271 */ + 0x00004002, 0x54000000, 0x60400300, 0x00002120, + 0x0000a022, 0x00000000, 0x81060803, 0x08010200, + } }, + { { /* 272 */ + 0x04004800, 0xb0044000, 0x0000a005, 0x04500800, + 0x800c000a, 0x0000c000, 0x10000800, 0x02408021, + } }, + { { /* 273 */ + 0x08020000, 0x00001040, 0x00540a40, 0x00000000, + 0x00800880, 0x01020002, 0x00000211, 0x00000010, + } }, + { { /* 274 */ + 0x00000000, 0x80000002, 0x00002000, 0x00080001, + 0x09840a00, 0x40000080, 0x00400000, 0x49000080, + } }, + { { /* 275 */ + 0x0e102831, 0x06098807, 0x40011014, 0x02620042, + 0x06000000, 0x88062000, 0x04068400, 0x08108301, + } }, + { { /* 276 */ + 0x08000012, 0x40004840, 0x00300402, 0x00012000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 277 */ + 0x00000000, 0x00400000, 0x00000000, 0x00a54400, + 0x40004420, 0x20000310, 0x00041002, 0x18000000, + } }, + { { /* 278 */ + 0x00a1002a, 0x00080000, 0x40400000, 0x00900000, + 0x21401200, 0x04048626, 0x40005048, 0x21100000, + } }, + { { /* 279 */ + 0x040005a4, 0x000a0000, 0x00214000, 0x07010800, + 0x34000000, 0x00080100, 0x00080040, 0x10182508, + } }, + { { /* 280 */ + 0xc0805100, 0x02c01400, 0x00000080, 0x00448040, + 0x20000800, 0x210a8000, 0x08800000, 0x00020060, + } }, + { { /* 281 */ + 0x00004004, 0x00400100, 0x01040200, 0x00800000, + 0x00000000, 0x00000000, 0x10081400, 0x00008000, + } }, + { { /* 282 */ + 0x00004000, 0x20000000, 0x08800200, 0x00001000, + 0x00000000, 0x01000000, 0x00000810, 0x00000000, + } }, + { { /* 283 */ + 0x00020000, 0x20200000, 0x00000000, 0x00000000, + 0x00000010, 0x00001c40, 0x00002000, 0x08000210, + } }, + { { /* 284 */ + 0x00000000, 0x00000000, 0x54014000, 0x02000800, + 0x00200400, 0x00000000, 0x00002080, 0x00004000, + } }, + { { /* 285 */ + 0x10000004, 0x00000000, 0x00000000, 0x00000000, + 0x00002000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 286 */ + 0x00000000, 0x00000000, 0x28881041, 0x0081010a, + 0x00400800, 0x00000800, 0x10208026, 0x61000000, + } }, + { { /* 287 */ + 0x00050080, 0x00000000, 0x80000000, 0x80040000, + 0x044088c2, 0x00080480, 0x00040000, 0x00000048, + } }, + { { /* 288 */ + 0x8188410d, 0x141a2400, 0x40310000, 0x000f4249, + 0x41283280, 0x80053011, 0x00400880, 0x410060c0, + } }, + { { /* 289 */ + 0x2a004013, 0x02000002, 0x11000000, 0x00850040, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 290 */ + 0x00000000, 0x00800000, 0x04000440, 0x00000402, + 0x60001000, 0x99909f87, 0x5808049d, 0x10002445, + } }, + { { /* 291 */ + 0x00000100, 0x00000000, 0x00000000, 0x00910050, + 0x00000420, 0x00080008, 0x20000000, 0x00288002, + } }, + { { /* 292 */ + 0x00008400, 0x00000400, 0x00000000, 0x00100000, + 0x00002000, 0x00000800, 0x80043400, 0x21000004, + } }, + { { /* 293 */ + 0x20000208, 0x01000600, 0x00000010, 0x00000000, + 0x48000000, 0x14060008, 0x00124020, 0x20812800, + } }, + { { /* 294 */ + 0xa419804b, 0x01064009, 0x10386ca4, 0x85a0620b, + 0x00000010, 0x01000448, 0x00004400, 0x20a02102, + } }, + { { /* 295 */ + 0x00000000, 0x00000000, 0x00147000, 0x01a01404, + 0x10040000, 0x01000000, 0x3002f180, 0x00000008, + } }, + { { /* 296 */ + 0x00002000, 0x00100000, 0x08000010, 0x00020004, + 0x01000029, 0x00002000, 0x00000000, 0x10082000, + } }, + { { /* 297 */ + 0x00000000, 0x0004d041, 0x08000800, 0x00200000, + 0x00401000, 0x00004000, 0x00000000, 0x00000002, + } }, + { { /* 298 */ + 0x01000000, 0x00000000, 0x00020000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 299 */ + 0x00000000, 0x00000000, 0x00000000, 0x00800000, + 0x000a0a01, 0x0004002c, 0x01000080, 0x00000000, + } }, + { { /* 300 */ + 0x10000000, 0x08040400, 0x08012010, 0x2569043c, + 0x1a10c460, 0x08800009, 0x000210f0, 0x08c5050c, + } }, + { { /* 301 */ + 0x10000481, 0x00040080, 0x42040000, 0x00100204, + 0x00000000, 0x00000000, 0x00080000, 0x88080000, + } }, + { { /* 302 */ + 0x010f016c, 0x18002000, 0x41307000, 0x00000080, + 0x00000000, 0x00000100, 0x88000000, 0x70048004, + } }, + { { /* 303 */ + 0x00081420, 0x00000100, 0x00000000, 0x00000000, + 0x02400000, 0x00001000, 0x00050070, 0x00000000, + } }, + { { /* 304 */ + 0x000c4000, 0x00010000, 0x04000000, 0x00000000, + 0x00000000, 0x01000100, 0x01000010, 0x00000400, + } }, + { { /* 305 */ + 0x00000000, 0x10020000, 0x04100024, 0x00000000, + 0x00000000, 0x00004000, 0x00000000, 0x00000100, + } }, + { { /* 306 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00100020, + } }, + { { /* 307 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00008000, 0x00100000, 0x00000000, 0x00000000, + } }, + { { /* 308 */ + 0x00000000, 0x00000000, 0x00000000, 0x80000000, + 0x00880000, 0x0c000040, 0x02040010, 0x00000000, + } }, + { { /* 309 */ + 0x00080000, 0x08000000, 0x00000000, 0x00000004, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 310 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xffffffff, 0xffffffff, 0xc3ff3fff, 0x00000000, + } }, + { { /* 311 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0xffff0000, 0x0001ffff, + } }, + { { /* 312 */ + 0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000, + 0x0c0c0000, 0x000cc00c, 0x03000000, 0x00000000, + } }, + { { /* 313 */ + 0xfffdffff, 0xc7ffffff, 0x03ffffff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 314 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xffffffff, 0xffff0fff, 0xc7ff03ff, 0x00000000, + } }, + { { /* 315 */ + 0x00000000, 0x00000300, 0x00000000, 0x00000300, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 316 */ + 0xffff0000, 0xffffffff, 0x0040ffff, 0x00000000, + 0x0c0c0000, 0x0c00000c, 0x03000000, 0x00000300, + } }, + { { /* 317 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x0d10646e, 0x0d10646e, + } }, + { { /* 318 */ + 0x00000000, 0x01000300, 0x00000000, 0x00000300, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 319 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x9fffffff, 0xffcffee7, 0x0000003f, 0x00000000, + } }, + { { /* 320 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xfffddfec, 0xc3effdff, 0x40603ddf, 0x00000003, + } }, + { { /* 321 */ + 0x00000000, 0xfffe0000, 0xffffffff, 0xffffffef, + 0x00007fff, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 322 */ + 0x3eff0793, 0x1303b011, 0x11102801, 0x05930000, + 0xb0111e7b, 0x3b019703, 0x00a01112, 0x306b9593, + } }, + { { /* 323 */ + 0x1102b051, 0x11303201, 0x011102b0, 0xb879300a, + 0x30011306, 0x00800010, 0x100b0113, 0x93000011, + } }, + { { /* 324 */ + 0x00102b03, 0x05930000, 0xb051746b, 0x3b011323, + 0x00001030, 0x70000000, 0x1303b011, 0x11102900, + } }, + { { /* 325 */ + 0x00012180, 0xb0153000, 0x3001030e, 0x02000030, + 0x10230111, 0x13000000, 0x10106b81, 0x01130300, + } }, + { { /* 326 */ + 0x30111013, 0x00000100, 0x22b85530, 0x30000000, + 0x9702b011, 0x113afb07, 0x011303b0, 0x00000021, + } }, + { { /* 327 */ + 0x3b0d1b00, 0x03b01138, 0x11330113, 0x13000001, + 0x111c2b05, 0x00000100, 0xb0111000, 0x2a011300, + } }, + { { /* 328 */ + 0x02b01930, 0x10100001, 0x11000000, 0x10300301, + 0x07130230, 0x0011146b, 0x2b051300, 0x8fb8f974, + } }, + { { /* 329 */ + 0x103b0113, 0x00000000, 0xd9700000, 0x01134ab0, + 0x0011103b, 0x00001103, 0x2ab15930, 0x10000111, + } }, + { { /* 330 */ + 0x11010000, 0x00100b01, 0x01130000, 0x0000102b, + 0x20000101, 0x02a01110, 0x30210111, 0x0102b059, + } }, + { { /* 331 */ + 0x19300000, 0x011307b0, 0xb011383b, 0x00000003, + 0x00000000, 0x383b0d13, 0x0103b011, 0x00001000, + } }, + { { /* 332 */ + 0x01130000, 0x00101020, 0x00000100, 0x00000110, + 0x30000000, 0x00021811, 0x00100000, 0x01110000, + } }, + { { /* 333 */ + 0x00000023, 0x0b019300, 0x00301110, 0x302b0111, + 0x13c7b011, 0x01303b01, 0x00000280, 0xb0113000, + } }, + { { /* 334 */ + 0x2b011383, 0x03b01130, 0x300a0011, 0x1102b011, + 0x00002000, 0x01110100, 0xa011102b, 0x2b011302, + } }, + { { /* 335 */ + 0x01000010, 0x30000001, 0x13029011, 0x11302b01, + 0x000066b0, 0xb0113000, 0x6b07d302, 0x07b0113a, + } }, + { { /* 336 */ + 0x00200103, 0x13000000, 0x11386b05, 0x011303b0, + 0x000010b8, 0x2b051b00, 0x03000110, 0x10000000, + } }, + { { /* 337 */ + 0x1102a011, 0x79700a01, 0x0111a2b0, 0x0000100a, + 0x00011100, 0x00901110, 0x00090111, 0x93000000, + } }, + { { /* 338 */ + 0xf9f2bb05, 0x011322b0, 0x2001323b, 0x00000000, + 0x06b05930, 0x303b0193, 0x1123a011, 0x11700000, + } }, + { { /* 339 */ + 0x001102b0, 0x00001010, 0x03011301, 0x00000110, + 0x162b0793, 0x01010010, 0x11300000, 0x01110200, + } }, + { { /* 340 */ + 0xb0113029, 0x00000000, 0x0eb05130, 0x383b0513, + 0x0303b011, 0x00000100, 0x01930000, 0x00001039, + } }, + { { /* 341 */ + 0x3b000302, 0x00000000, 0x00230113, 0x00000000, + 0x00100000, 0x00010000, 0x90113020, 0x00000002, + } }, + { { /* 342 */ + 0x00000000, 0x10000000, 0x11020000, 0x00000301, + 0x01130000, 0xb079b02b, 0x3b011323, 0x02b01130, + } }, + { { /* 343 */ + 0xf0210111, 0x1343b0d9, 0x11303b01, 0x011103b0, + 0xb0517020, 0x20011322, 0x01901110, 0x300b0111, + } }, + { { /* 344 */ + 0x9302b011, 0x0016ab01, 0x01130100, 0xb0113021, + 0x29010302, 0x02b03130, 0x30000000, 0x1b42b819, + } }, + { { /* 345 */ + 0x11383301, 0x00000330, 0x00000020, 0x33051300, + 0x00001110, 0x00000000, 0x93000000, 0x01302305, + } }, + { { /* 346 */ + 0x00010100, 0x30111010, 0x00000100, 0x02301130, + 0x10100001, 0x11000000, 0x00000000, 0x85130200, + } }, + { { /* 347 */ + 0x10111003, 0x2b011300, 0x63b87730, 0x303b0113, + 0x11a2b091, 0x7b300201, 0x011357f0, 0xf0d1702b, + } }, + { { /* 348 */ + 0x1b0111e3, 0x0ab97130, 0x303b0113, 0x13029001, + 0x11302b01, 0x071302b0, 0x3011302b, 0x23011303, + } }, + { { /* 349 */ + 0x02b01130, 0x30ab0113, 0x11feb411, 0x71300901, + 0x05d347b8, 0xb011307b, 0x21015303, 0x00001110, + } }, + { { /* 350 */ + 0x306b0513, 0x1102b011, 0x00103301, 0x05130000, + 0xa01038eb, 0x30000102, 0x02b01110, 0x30200013, + } }, + { { /* 351 */ + 0x0102b071, 0x00101000, 0x01130000, 0x1011100b, + 0x2b011300, 0x00000000, 0x366b0593, 0x1303b095, + } }, + { { /* 352 */ + 0x01103b01, 0x00000200, 0xb0113000, 0x20000103, + 0x01000010, 0x30000000, 0x030ab011, 0x00101001, + } }, + { { /* 353 */ + 0x01110100, 0x00000003, 0x23011302, 0x03000010, + 0x10000000, 0x01000000, 0x00100000, 0x00000290, + } }, + { { /* 354 */ + 0x30113000, 0x7b015386, 0x03b01130, 0x00210151, + 0x13000000, 0x11303b01, 0x001102b0, 0x00011010, + } }, + { { /* 355 */ + 0x2b011302, 0x02001110, 0x10000000, 0x0102b011, + 0x11300100, 0x000102b0, 0x00011010, 0x2b011100, + } }, + { { /* 356 */ + 0x02101110, 0x002b0113, 0x93000000, 0x11302b03, + 0x011302b0, 0x0000303b, 0x00000002, 0x03b01930, + } }, + { { /* 357 */ + 0x102b0113, 0x0103b011, 0x11300000, 0x011302b0, + 0x00001021, 0x00010102, 0x00000010, 0x102b0113, + } }, + { { /* 358 */ + 0x01020011, 0x11302000, 0x011102b0, 0x30113001, + 0x00000002, 0x02b01130, 0x303b0313, 0x0103b011, + } }, + { { /* 359 */ + 0x00002000, 0x05130000, 0xb011303b, 0x10001102, + 0x00000110, 0x142b0113, 0x01000001, 0x01100000, + } }, + { { /* 360 */ + 0x00010280, 0xb0113000, 0x10000102, 0x00000010, + 0x10230113, 0x93021011, 0x11100b05, 0x01130030, + } }, + { { /* 361 */ + 0xb051702b, 0x3b011323, 0x00000030, 0x30000000, + 0x1303b011, 0x11102b01, 0x01010330, 0xb011300a, + } }, + { { /* 362 */ + 0x20000102, 0x00000000, 0x10000011, 0x9300a011, + 0x00102b05, 0x00000200, 0x90111000, 0x29011100, + } }, + { { /* 363 */ + 0x00b01110, 0x30000000, 0x1302b011, 0x11302b21, + 0x000103b0, 0x00000020, 0x2b051300, 0x02b01130, + } }, + { { /* 364 */ + 0x103b0113, 0x13002011, 0x11322b21, 0x00130280, + 0xa0113028, 0x0a011102, 0x02921130, 0x30210111, + } }, + { { /* 365 */ + 0x13020011, 0x11302b01, 0x03d30290, 0x3011122b, + 0x2b011302, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 366 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00004000, 0x00000000, 0x20000000, 0x00000000, + } }, + { { /* 367 */ + 0x00000000, 0x00000000, 0x00003000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 368 */ + 0x00000000, 0x040001df, 0x80800176, 0x420c0000, + 0x01020140, 0x44008200, 0x00041018, 0x00000000, + } }, + { { /* 369 */ + 0xffff0000, 0xffff27bf, 0x000027bf, 0x00000000, + 0x00000000, 0x0c000000, 0x03000000, 0x000000c0, + } }, + { { /* 370 */ + 0x3c000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 371 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x08004480, 0x08004480, + } }, + { { /* 372 */ + 0x00000000, 0x00000000, 0xc0000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 373 */ + 0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 374 */ + 0xffff0042, 0xffffffff, 0x0042ffff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x000000c0, + } }, + { { /* 375 */ + 0x00000000, 0x000c0000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 376 */ + 0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000, + 0x00000000, 0x0000c00c, 0x00000000, 0x00000000, + } }, + { { /* 377 */ + 0x000c0003, 0x00003c00, 0x0000f000, 0x00003c00, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 378 */ + 0x00000000, 0x040001de, 0x00000176, 0x42000000, + 0x01020140, 0x44008200, 0x00041008, 0x00000000, + } }, + { { /* 379 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x98504f14, 0x18504f14, + } }, + { { /* 380 */ + 0xffffffff, 0xf8ffffff, 0x0000e3ff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 381 */ + 0x00000000, 0x00000000, 0x00000c00, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 382 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00480910, 0x00480910, + } }, + { { /* 383 */ + 0x7fffffff, 0x0fff0fff, 0x0000fff1, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 384 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x060cb301, 0x060eb3d5, + } }, + { { /* 385 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0xffff0000, 0xffffffff, + } }, + { { /* 386 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x0c186606, 0x0c186606, + } }, + { { /* 387 */ + 0x0c000000, 0x00000000, 0x00000000, 0x00000000, + 0x00010040, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 388 */ + 0x00001006, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 389 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xfef02596, 0x3bffecae, 0x30003f5f, 0x00000000, + } }, + { { /* 390 */ + 0x03c03030, 0x0000c000, 0x00000000, 0x600c0c03, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 391 */ + 0x000c3003, 0x18c00c0c, 0x00c03060, 0x60000c03, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 392 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00100002, 0x00100002, + } }, + { { /* 393 */ + 0x00000003, 0x18000000, 0x00003060, 0x00000c00, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 394 */ + 0x00000000, 0x00300000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 395 */ + 0x00000000, 0x00000000, 0x4fffffff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 396 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x140a2202, 0x142a220a, + } }, + { { /* 397 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x20000000, 0x00000000, 0x00000000, + } }, + { { /* 398 */ + 0xfdffb729, 0x000001ff, 0xb7290000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 399 */ + 0xfffddfec, 0xc3fffdff, 0x00803dcf, 0x00000003, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 400 */ + 0x00000000, 0xffffffff, 0xffffffff, 0x00ffffff, + 0xffffffff, 0x000003ff, 0x00000000, 0x00000000, + } }, + { { /* 401 */ + 0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000, + 0x00000000, 0x0000c000, 0x00000000, 0x00000300, + } }, + { { /* 402 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x007fffff, + } }, + { { /* 403 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0xffffffff, 0x03ff37ff, + } }, + { { /* 404 */ + 0xffffffff, 0x0007f6fb, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 405 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00004004, 0x00004004, + } }, + { { /* 406 */ + 0x0f000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 407 */ + 0x00000000, 0x00000000, 0x7fffffff, 0x0000c3ff, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 408 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x02045101, 0x02045101, + } }, + { { /* 409 */ + 0x00000c00, 0x000000c3, 0x00000000, 0x18000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 410 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000300, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 411 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x011c0661, 0x011c0661, + } }, + { { /* 412 */ + 0xfff98fee, 0xc3e5fdff, 0x0001398f, 0x0001fff0, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 413 */ + 0x00000002, 0x00000000, 0x00002000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 414 */ + 0x00080002, 0x00000800, 0x00002000, 0x00000800, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 415 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x1c58af16, 0x1c58af16, + } }, + { { /* 416 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x115c0671, 0x115c0671, + } }, + { { /* 417 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0xffffffff, 0x83ffffff, + } }, + { { /* 418 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0xffffffff, 0x07ffffff, + } }, + { { /* 419 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00100400, 0x00100400, + } }, + { { /* 420 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000003, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 421 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00082202, 0x00082202, + } }, + { { /* 422 */ + 0x03000030, 0x0000c000, 0x00000006, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000c00, + } }, + { { /* 423 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x10000000, 0x00000000, 0x00000000, + } }, + { { /* 424 */ + 0x00000002, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 425 */ + 0x00000000, 0x00000000, 0x00000000, 0x00300000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 426 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x040c2383, 0x040c2383, + } }, + { { /* 427 */ + 0xfff99fee, 0xf3cdfdff, 0xb0c0398f, 0x00000003, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 428 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0xffff0000, 0xff0fffff, 0x0fffffff, + } }, + { { /* 429 */ + 0x00000000, 0x07ffffc6, 0x000001fe, 0x40000000, + 0x01000040, 0x0000a000, 0x00001000, 0x00000000, + } }, + { { /* 430 */ + 0xffffffff, 0xffffffff, 0x000001ff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 431 */ + 0x00000000, 0x00000000, 0x00000000, 0xffff0000, + 0x000003ff, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 432 */ + 0xfff987e0, 0xd36dfdff, 0x1e003987, 0x001f0000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 433 */ + 0x00000000, 0x00000000, 0x00000000, 0xff07ffff, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 434 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x160e2302, 0x160e2302, + } }, + { { /* 435 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00020000, 0x00020000, + } }, + { { /* 436 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0xffffffff, 0x003fff0f, 0x00000000, + } }, + { { /* 437 */ + 0xfeeff06f, 0x873fffff, 0x01ff01ff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 438 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x1fffffff, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 439 */ + 0x8fffffff, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 440 */ + 0x030000f0, 0x00000000, 0x0c00001e, 0x1e000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 441 */ + 0x00000000, 0x07ffffde, 0x000005f6, 0x50000000, + 0x05480262, 0x10000a00, 0x00013000, 0x00000000, + } }, + { { /* 442 */ + 0x00000000, 0x07ffffde, 0x000005f6, 0x50000000, + 0x05480262, 0x10000a00, 0x00052000, 0x00000000, + } }, + { { /* 443 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x143c278f, 0x143c278f, + } }, + { { /* 444 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000100, 0x00000000, + } }, + { { /* 445 */ + 0xffffffff, 0x03ff00ff, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 446 */ + 0x00002000, 0x00000000, 0x02000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000080, + } }, + { { /* 447 */ + 0x00002000, 0x00000020, 0x08000000, 0x00002008, + 0x00080000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 448 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x02045301, 0x02045301, + } }, + { { /* 449 */ + 0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000, + 0x00300000, 0x0c00c030, 0x03000000, 0x00000000, + } }, + { { /* 450 */ + 0xffffffff, 0x7fff3fff, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 451 */ + 0x00000000, 0x00000000, 0xffff0000, 0xffffffff, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 452 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x02041101, 0x02041101, + } }, + { { /* 453 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00800000, 0x00000000, 0x00000000, + } }, + { { /* 454 */ + 0x30000000, 0x00000000, 0x00000000, 0x00000000, + 0x00040000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 455 */ + 0x00000000, 0x07fffdd6, 0x000005f6, 0xec000000, + 0x0200b4d9, 0x480a8640, 0x00000000, 0x00000000, + } }, + { { /* 456 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00000002, 0x00000002, + } }, + { { /* 457 */ + 0x00033000, 0x00000000, 0x00000c00, 0x600000c3, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 458 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x1850cc14, 0x1850cc14, + } }, + { { /* 459 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00000000, 0x00200000, + } }, + { { /* 460 */ + 0x03c83032, 0x0000c800, 0x00002000, 0x600c0c03, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 461 */ + 0x00000010, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 462 */ + 0xffff8f04, 0xffffffff, 0x8f04ffff, 0x00000000, + 0x030c0000, 0x0c00cc0f, 0x03000000, 0x00000300, + } }, + { { /* 463 */ + 0x00000000, 0x00800000, 0x03bffbaa, 0x03bffbaa, + 0x00000000, 0x00000000, 0x00002202, 0x00002202, + } }, + { { /* 464 */ + 0x00080000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 465 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xfc7e3fec, 0x2ffbffbf, 0x7f5f847f, 0x00040000, + } }, + { { /* 466 */ + 0xff7fff7f, 0xff01ff7f, 0x3d7f3d7f, 0xffff7fff, + 0xffff3d7f, 0x003d7fff, 0xff7f7f3d, 0x00ff7fff, + } }, + { { /* 467 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x24182212, 0x24182212, + } }, + { { /* 468 */ + 0x0000f000, 0x66000000, 0x00300180, 0x60000033, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 469 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00408030, 0x00408030, + } }, + { { /* 470 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00020032, 0x00020032, + } }, + { { /* 471 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00000016, 0x00000016, + } }, + { { /* 472 */ + 0x00033000, 0x00000000, 0x00000c00, 0x60000003, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 473 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00200034, 0x00200034, + } }, + { { /* 474 */ + 0x00033000, 0x00000000, 0x00000c00, 0x60000003, + 0x00000000, 0x00800000, 0x00000000, 0x0000c3f0, + } }, + { { /* 475 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00040000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 476 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x3fffffff, 0x000003ff, 0x00000000, 0x00000000, + } }, + { { /* 477 */ + 0x00000000, 0xffff0000, 0x03ffffff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 478 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00000880, 0x00000880, + } }, + { { /* 479 */ + 0xfdff8f04, 0xfdff01ff, 0x8f0401ff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 480 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xffffffff, 0xffffffff, 0x00000000, 0x00000000, + } }, + { { /* 481 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x000000ff, 0x00000000, + } }, + { { /* 482 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0xffffffff, 0x03ff0003, + } }, + { { /* 483 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x10400a33, 0x10400a33, + } }, + { { /* 484 */ + 0xffff0000, 0xffff1fff, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 485 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00380008, 0x00080000, + } }, + { { /* 486 */ + 0x030000f0, 0x00000000, 0x0c00501e, 0x1e004000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 487 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xd63dc7e8, 0xc3bfc718, 0x00803dc7, 0x00000000, + } }, + { { /* 488 */ + 0x00000000, 0x00000000, 0x00000000, 0x000ddfff, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 489 */ + 0x00000000, 0x00000000, 0xffff0000, 0x001f3fff, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 490 */ + 0xfffddfee, 0xc3effdff, 0x00603ddf, 0x00000003, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 491 */ + 0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000, + 0x0c0c0000, 0x00cc0000, 0x00000000, 0x0000c00c, + } }, + { { /* 492 */ + 0xfffffffe, 0x87ffffff, 0x00007fff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 493 */ + 0xff7fff7f, 0xff01ff00, 0x00003d7f, 0xffff7fff, + 0x00ff0000, 0x003d7f7f, 0xff7f7f00, 0x00ff7f00, + } }, + { { /* 494 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x30400090, 0x30400090, + } }, + { { /* 495 */ + 0x00000000, 0x00000000, 0xc0000180, 0x60000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 496 */ + 0x803fffff, 0x00600000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 497 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x18404084, 0x18404084, + } }, + { { /* 498 */ + 0xffff0002, 0xffffffff, 0x0002ffff, 0x00000000, + 0x00c00000, 0x0c00c00c, 0x03000000, 0x00000000, + } }, + { { /* 499 */ + 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, + 0xffffffff, 0xffffffff, 0xffffffff, 0x00ffffff, + } }, + { { /* 500 */ + 0x000001ff, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 501 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00008000, 0x00008000, + } }, + { { /* 502 */ + 0x00000000, 0x041ed5c0, 0x0000077e, 0x40000000, + 0x01000040, 0x4000a000, 0x002109c0, 0x00000000, + } }, + { { /* 503 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xbfffffff, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 504 */ + 0xffff00d0, 0xffffffff, 0x00d0ffff, 0x00000000, + 0x00030000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 505 */ + 0x00000000, 0xffffff7b, 0x7fffffff, 0x7ffffffe, + 0x00000000, 0x80e310fe, 0x00800000, 0x00800000, + } }, + { { /* 506 */ + 0x00000000, 0x00020000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 507 */ + 0x00001500, 0x01000000, 0x00000000, 0x00000000, + 0xfffe0000, 0xfffe03db, 0x006003fb, 0x00030000, + } }, + { { /* 508 */ + 0x00400000, 0x00000047, 0x00800010, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000002, + } }, + { { /* 509 */ + 0x3f2fc004, 0x00000010, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 510 */ + 0xe3ffbfff, 0xfff007ff, 0x00000001, 0x00000000, + 0xfffff000, 0x0000003f, 0x0000e10f, 0x00000000, + } }, + { { /* 511 */ + 0x00000f00, 0x0000000c, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 512 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000003, 0x00000000, 0x00000000, + } }, + { { /* 513 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x000003c0, + } }, + { { /* 514 */ + 0xffffffff, 0xffffffff, 0xffdfffff, 0xffffffff, + 0xdfffffff, 0x00001e64, 0x00000000, 0x00000000, + } }, + { { /* 515 */ + 0x00000000, 0x78000000, 0x0001fc5f, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 516 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000030, 0x00000000, 0x00000000, + } }, + { { /* 517 */ + 0x0c000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00091e00, + } }, + { { /* 518 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x60000000, + } }, + { { /* 519 */ + 0x00300000, 0x00000000, 0x000fff00, 0x80000000, + 0x00080000, 0x60000c02, 0x00104030, 0x242c0400, + } }, + { { /* 520 */ + 0x00000c20, 0x00000100, 0x00b85000, 0x00000000, + 0x00e00000, 0x80010000, 0x00000000, 0x00000000, + } }, + { { /* 521 */ + 0x18000000, 0x00000000, 0x00210000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 522 */ + 0x00000010, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00008000, 0x00000000, + } }, + { { /* 523 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x07fe4000, 0x00000000, 0x00000000, 0xffffffc0, + } }, + { { /* 524 */ + 0x04000002, 0x077c8000, 0x00030000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 525 */ + 0xffffffff, 0xffbf0001, 0xffffffff, 0x1fffffff, + 0x000fffff, 0xffffffff, 0x000007df, 0x0001ffff, + } }, + { { /* 526 */ + 0x00000000, 0x00000000, 0xfffffffd, 0xffffffff, + 0xffffffff, 0xffffffff, 0xffffffff, 0x1effffff, + } }, + { { /* 527 */ + 0xffffffff, 0x3fffffff, 0xffff0000, 0x000000ff, + 0x00000000, 0x00000000, 0x00000000, 0xf8000000, + } }, + { { /* 528 */ + 0x755dfffe, 0xffef2f3f, 0x0000ffe1, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 529 */ + 0xffffffff, 0x00000fff, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 530 */ + 0x000c0000, 0x30000000, 0x00000c30, 0x00030000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 531 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x263c370f, 0x263c370f, + } }, + { { /* 532 */ + 0x0003000c, 0x00000300, 0x00000000, 0x00000300, + 0x00000000, 0x00018003, 0x00000000, 0x00000000, + } }, + { { /* 533 */ + 0x0800024f, 0x00000008, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 534 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0xffffffff, 0xffffffff, 0x03ffffff, + } }, + { { /* 535 */ + 0x00000000, 0x00000000, 0x077dfffe, 0x077dfffe, + 0x00000000, 0x00000000, 0x10400010, 0x10400010, + } }, + { { /* 536 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x10400010, 0x10400010, + } }, + { { /* 537 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x081047a4, 0x081047a4, + } }, + { { /* 538 */ + 0x0c0030c0, 0x00000000, 0x0f30001e, 0x66000003, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 539 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x000a0a09, 0x000a0a09, + } }, + { { /* 540 */ + 0x00000000, 0xffff0000, 0xffffffff, 0x0000800f, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 541 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0xffff0000, 0x00000fff, 0x00000000, + } }, + { { /* 542 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0xffffffff, 0x0001ffff, 0x00000000, + } }, + { { /* 543 */ + 0x00000000, 0x83ffffff, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 544 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xffffffff, 0xf0ffffff, 0xfffcffff, 0xffffffff, + } }, + { { /* 545 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0xffffffff, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 546 */ + 0x00000000, 0x00000000, 0xff3fffff, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 547 */ + 0x00000000, 0x00000000, 0x00000000, 0xffffffff, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 548 */ + 0x00000000, 0x00000000, 0x00000000, 0xffff0000, + 0xfffcffff, 0x007ffeff, 0x00000000, 0x00000000, + } }, + { { /* 549 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x00400810, 0x00400810, + } }, + { { /* 550 */ + 0x00000000, 0x00000000, 0x07fffffe, 0x07fffffe, + 0x00000000, 0x00000000, 0x0e3c770f, 0x0e3c770f, + } }, + { { /* 551 */ + 0x0c000000, 0x00000300, 0x00000018, 0x00000300, + 0x00000000, 0x00000000, 0x001fe000, 0x03000000, + } }, + { { /* 552 */ + 0x0000100f, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 553 */ + 0x00000000, 0xc0000000, 0x00000000, 0x0000000c, + 0x00000000, 0x33000000, 0x00003000, 0x00000000, + } }, + { { /* 554 */ + 0x00000080, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 555 */ + 0x00000000, 0x00000000, 0x00001000, 0x64080010, + 0x00480000, 0x10000020, 0x80000102, 0x08000010, + } }, + { { /* 556 */ + 0x00000040, 0x40000000, 0x00020000, 0x01852002, + 0x00800010, 0x80002022, 0x084444a2, 0x480e0000, + } }, + { { /* 557 */ + 0x04000200, 0x02202008, 0x80004380, 0x04000000, + 0x00000002, 0x12231420, 0x2058003a, 0x00200060, + } }, + { { /* 558 */ + 0x10002508, 0x040d0028, 0x00000009, 0x00008004, + 0x00800000, 0x42000001, 0x00000000, 0x09040000, + } }, + { { /* 559 */ + 0x02008000, 0x01402001, 0x00000000, 0x00000008, + 0x00000000, 0x00000001, 0x00021008, 0x04000000, + } }, + { { /* 560 */ + 0x00100100, 0x80040080, 0x00002000, 0x00000008, + 0x08040601, 0x01000012, 0x10000000, 0x49001024, + } }, + { { /* 561 */ + 0x0180004a, 0x00100600, 0x50840800, 0x000000c0, + 0x00800000, 0x20000800, 0x40000000, 0x08050000, + } }, + { { /* 562 */ + 0x02004000, 0x02000804, 0x01000004, 0x18060001, + 0x02400001, 0x40000002, 0x20800014, 0x000c1000, + } }, + { { /* 563 */ + 0x00222000, 0x00000000, 0x00100000, 0x00000000, + 0x00000000, 0x00000000, 0x10422800, 0x00000800, + } }, + { { /* 564 */ + 0x20080000, 0x00040000, 0x80025040, 0x20208604, + 0x00028020, 0x80102020, 0x080820c0, 0x10880800, + } }, + { { /* 565 */ + 0x00000000, 0x00000000, 0x00200109, 0x00100000, + 0x00000000, 0x81022700, 0x40c21404, 0x84010882, + } }, + { { /* 566 */ + 0x00004010, 0x00000000, 0x03000000, 0x00000008, + 0x00080000, 0x00000000, 0x10800001, 0x06002020, + } }, + { { /* 567 */ + 0x00000010, 0x02000000, 0x00880020, 0x00008424, + 0x00000000, 0x88000000, 0x81000100, 0x04000000, + } }, + { { /* 568 */ + 0x00004218, 0x00040000, 0x00000000, 0x80005080, + 0x00010000, 0x00040000, 0x08008000, 0x02008000, + } }, + { { /* 569 */ + 0x00020000, 0x00000000, 0x00000001, 0x04000401, + 0x00100000, 0x12200004, 0x00000000, 0x18100000, + } }, + { { /* 570 */ + 0x00000000, 0x00000800, 0x00000000, 0x00004000, + 0x00800000, 0x04000000, 0x82000002, 0x00042000, + } }, + { { /* 571 */ + 0x00080006, 0x00000000, 0x00000000, 0x04000000, + 0x80008000, 0x00810001, 0xa0000000, 0x00100410, + } }, + { { /* 572 */ + 0x00400218, 0x88084080, 0x00260008, 0x00800404, + 0x00000020, 0x00000000, 0x00000000, 0x00000200, + } }, + { { /* 573 */ + 0x00a08048, 0x00000000, 0x08000000, 0x04000000, + 0x00000000, 0x00000000, 0x00018000, 0x00200000, + } }, + { { /* 574 */ + 0x01000000, 0x00000000, 0x00000000, 0x10000000, + 0x00000000, 0x00000000, 0x00200000, 0x00102000, + } }, + { { /* 575 */ + 0x00000801, 0x00000000, 0x00000000, 0x00020000, + 0x08000000, 0x00002000, 0x20010000, 0x04002000, + } }, + { { /* 576 */ + 0x40000040, 0x50202400, 0x000a0020, 0x00040420, + 0x00000200, 0x00000080, 0x80000000, 0x00000020, + } }, + { { /* 577 */ + 0x20008000, 0x00200010, 0x00000000, 0x00000000, + 0x00400000, 0x01100000, 0x00020000, 0x80000010, + } }, + { { /* 578 */ + 0x02000000, 0x00801000, 0x00000000, 0x48058000, + 0x20c94000, 0x60000000, 0x00000001, 0x00000000, + } }, + { { /* 579 */ + 0x00004090, 0x48000000, 0x08000000, 0x28802000, + 0x00000002, 0x00014000, 0x00002000, 0x00002002, + } }, + { { /* 580 */ + 0x00010200, 0x00100000, 0x00000000, 0x00800000, + 0x10020000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 581 */ + 0x00000010, 0x00000402, 0x0c000000, 0x01000400, + 0x01000021, 0x00000000, 0x00004000, 0x00004000, + } }, + { { /* 582 */ + 0x00000000, 0x00800000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x02000020, + } }, + { { /* 583 */ + 0x00000100, 0x08000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00002000, 0x00000000, + } }, + { { /* 584 */ + 0x00006000, 0x00000000, 0x00000000, 0x00000400, + 0x04000040, 0x003c0180, 0x00000200, 0x00102000, + } }, + { { /* 585 */ + 0x00000800, 0x101000c0, 0x00800000, 0x00000000, + 0x00008000, 0x02200000, 0x00020020, 0x00000000, + } }, + { { /* 586 */ + 0x00000000, 0x01000000, 0x00000000, 0x20100000, + 0x00080000, 0x00000141, 0x02001002, 0x40400001, + } }, + { { /* 587 */ + 0x00580000, 0x00000002, 0x00003000, 0x00002400, + 0x00988000, 0x00040010, 0x00002800, 0x00000008, + } }, + { { /* 588 */ + 0x40080004, 0x00000020, 0x20080000, 0x02060a00, + 0x00010040, 0x14010200, 0x40800000, 0x08031000, + } }, + { { /* 589 */ + 0x40020020, 0x0000202c, 0x2014a008, 0x00000000, + 0x80040200, 0x82020012, 0x00400000, 0x20000000, + } }, + { { /* 590 */ + 0x00000000, 0x00000000, 0x00000004, 0x04000000, + 0x00000000, 0x00000000, 0x40800100, 0x00000000, + } }, + { { /* 591 */ + 0x00000008, 0x04000040, 0x00000001, 0x000c0200, + 0x00000000, 0x08000400, 0x00000000, 0x080c0001, + } }, + { { /* 592 */ + 0x00000400, 0x00000000, 0x00000000, 0x00200000, + 0x80000000, 0x00001000, 0x00000200, 0x01000800, + } }, + { { /* 593 */ + 0x00000000, 0x00000800, 0x00000000, 0x40000000, + 0x00000000, 0x00000000, 0x00000000, 0x04040000, + } }, + { { /* 594 */ + 0x00000000, 0x00000000, 0x00000040, 0x00002000, + 0xa0000000, 0x00000000, 0x08000008, 0x00080000, + } }, + { { /* 595 */ + 0x00000020, 0x00000000, 0x40000400, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00008000, + } }, + { { /* 596 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000800, 0x00000000, 0x00000000, 0x00200000, + } }, + { { /* 597 */ + 0x00000000, 0x00000000, 0x00000000, 0x04000000, + 0x00000008, 0x00000000, 0x00010000, 0x1b000000, + } }, + { { /* 598 */ + 0x00007000, 0x00000000, 0x10000000, 0x00000000, + 0x00000000, 0x00000080, 0x80000000, 0x00000000, + } }, + { { /* 599 */ + 0x00000000, 0x00020000, 0x00000000, 0x00200000, + 0x40000000, 0x00000010, 0x00800000, 0x00000008, + } }, + { { /* 600 */ + 0x00000000, 0x00000000, 0x02000000, 0x20000010, + 0x00000080, 0x00000000, 0x00010000, 0x00000000, + } }, + { { /* 601 */ + 0x00000000, 0x02000000, 0x00000000, 0x00000000, + 0x20000000, 0x00000040, 0x00200028, 0x00000000, + } }, + { { /* 602 */ + 0x00000000, 0x00020000, 0x00000000, 0x02000000, + 0x00000000, 0x02000000, 0x40020000, 0x51000040, + } }, + { { /* 603 */ + 0x00000080, 0x04040000, 0x00000000, 0x10000000, + 0x00022000, 0x00100000, 0x20000000, 0x00000082, + } }, + { { /* 604 */ + 0x40000000, 0x00010000, 0x00002000, 0x00000000, + 0x00000240, 0x00000000, 0x00000000, 0x00000008, + } }, + { { /* 605 */ + 0x00000000, 0x00010000, 0x00000810, 0x00080880, + 0x00004000, 0x00000000, 0x00000000, 0x00020000, + } }, + { { /* 606 */ + 0x00000000, 0x00400020, 0x00000000, 0x00000082, + 0x00000000, 0x00020001, 0x00000000, 0x00000000, + } }, + { { /* 607 */ + 0x40000018, 0x00000004, 0x00000000, 0x00000000, + 0x01000000, 0x00400000, 0x00000000, 0x00000000, + } }, + { { /* 608 */ + 0x00000001, 0x00400000, 0x00000000, 0x00080002, + 0x00000400, 0x00040000, 0x00000000, 0x00000000, + } }, + { { /* 609 */ + 0x00000800, 0x00000800, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000100, 0x00000000, + } }, + { { /* 610 */ + 0x00000000, 0x00200000, 0x00000000, 0x04108000, + 0x00000000, 0x00000000, 0x00000000, 0x00000002, + } }, + { { /* 611 */ + 0x00000000, 0x02800000, 0x04000000, 0x00000000, + 0x00000000, 0x00000004, 0x00000000, 0x00000400, + } }, + { { /* 612 */ + 0x00000000, 0x00000000, 0x10000000, 0x00040000, + 0x00400000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 613 */ + 0x00200000, 0x00000200, 0x00000000, 0x10000000, + 0x00000000, 0x00000000, 0x2a000000, 0x00000000, + } }, + { { /* 614 */ + 0x00400000, 0x00000000, 0x00400000, 0x00000000, + 0x00000002, 0x40000000, 0x00000000, 0x00400000, + } }, + { { /* 615 */ + 0x40000000, 0x00001000, 0x00000000, 0x00000000, + 0x00000202, 0x02000000, 0x80000000, 0x00020000, + } }, + { { /* 616 */ + 0x00000020, 0x00000800, 0x00020421, 0x00020000, + 0x00000000, 0x00000000, 0x00000000, 0x00400000, + } }, + { { /* 617 */ + 0x00200000, 0x00000000, 0x00000001, 0x00000000, + 0x00000084, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 618 */ + 0x00000000, 0x00004400, 0x00000002, 0x00100000, + 0x00000000, 0x00000000, 0x00008200, 0x00000000, + } }, + { { /* 619 */ + 0x00000000, 0x12000000, 0x00000100, 0x00000001, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 620 */ + 0x00000020, 0x08100000, 0x000a0400, 0x00000081, + 0x00006000, 0x00120000, 0x00000000, 0x00000000, + } }, + { { /* 621 */ + 0x00000004, 0x08000000, 0x00004000, 0x044000c0, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 622 */ + 0x40001000, 0x00000000, 0x01000001, 0x05000000, + 0x00080000, 0x02000000, 0x00000800, 0x00000000, + } }, + { { /* 623 */ + 0x00000100, 0x00000000, 0x00000000, 0x00000000, + 0x00002002, 0x01020000, 0x00800000, 0x00000000, + } }, + { { /* 624 */ + 0x00000040, 0x00004000, 0x01000000, 0x00000004, + 0x00020000, 0x00000000, 0x00000010, 0x00000000, + } }, + { { /* 625 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00080000, 0x00010000, 0x30000300, 0x00000400, + } }, + { { /* 626 */ + 0x00000800, 0x02000000, 0x00000000, 0x00008000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 627 */ + 0x00200000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x000040c0, 0x00002200, 0x12002000, + } }, + { { /* 628 */ + 0x00000000, 0x00000020, 0x20000000, 0x00000000, + 0x00000200, 0x00080800, 0x1000a000, 0x00000000, + } }, + { { /* 629 */ + 0x00000000, 0x00000000, 0x00000000, 0x00004000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 630 */ + 0x00000000, 0x00000000, 0x00004280, 0x01000000, + 0x00800000, 0x00000008, 0x00000000, 0x00000000, + } }, + { { /* 631 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000002, + 0x00000000, 0x20400000, 0x00000040, 0x00000000, + } }, + { { /* 632 */ + 0x00800080, 0x00800000, 0x00000000, 0x00000000, + 0x00000000, 0x00400020, 0x00000000, 0x00008000, + } }, + { { /* 633 */ + 0x01000000, 0x00000040, 0x00000000, 0x00400000, + 0x00000000, 0x00000440, 0x00000000, 0x00800000, + } }, + { { /* 634 */ + 0x01000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00080000, 0x00000000, + } }, + { { /* 635 */ + 0x01000000, 0x00000001, 0x00000000, 0x00020000, + 0x00000000, 0x20002000, 0x00000000, 0x00000004, + } }, + { { /* 636 */ + 0x00000008, 0x00100000, 0x00000000, 0x00010000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 637 */ + 0x00000004, 0x00008000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00008000, + } }, + { { /* 638 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000040, 0x00000000, 0x00004000, 0x00000000, + } }, + { { /* 639 */ + 0x00000010, 0x00002000, 0x40000040, 0x00000000, + 0x10000000, 0x00000000, 0x00008080, 0x00000000, + } }, + { { /* 640 */ + 0x00000000, 0x00000000, 0x00000080, 0x00000000, + 0x00100080, 0x000000a0, 0x00000000, 0x00000000, + } }, + { { /* 641 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00100000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 642 */ + 0x00000000, 0x00000000, 0x00001000, 0x00000000, + 0x0001000a, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 643 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x08002000, 0x00000000, + } }, + { { /* 644 */ + 0x00000808, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 645 */ + 0x00004000, 0x00002400, 0x00008000, 0x40000000, + 0x00000001, 0x00002000, 0x04000000, 0x00040004, + } }, + { { /* 646 */ + 0x00000000, 0x00002000, 0x00000000, 0x00000000, + 0x00000000, 0x1c200000, 0x00000000, 0x02000000, + } }, + { { /* 647 */ + 0x00000000, 0x00080000, 0x00400000, 0x00000002, + 0x00000000, 0x00000100, 0x00000000, 0x00000000, + } }, + { { /* 648 */ + 0x00000000, 0x00000000, 0x00000000, 0x00400000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 649 */ + 0x00004100, 0x00000400, 0x20200010, 0x00004004, + 0x00000000, 0x42000000, 0x00000000, 0x00000000, + } }, + { { /* 650 */ + 0x00000080, 0x00000000, 0x00000121, 0x00000200, + 0x000000b0, 0x80002000, 0x00000000, 0x00010000, + } }, + { { /* 651 */ + 0x00000010, 0x000000c0, 0x08100000, 0x00000020, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 652 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02000000, 0x00000404, 0x00000000, 0x00000000, + } }, + { { /* 653 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00400000, 0x00000008, 0x00000000, 0x00000000, + } }, + { { /* 654 */ + 0x00000000, 0x00000002, 0x00020000, 0x00002000, + 0x00000000, 0x00000000, 0x00000000, 0x00204000, + } }, + { { /* 655 */ + 0x00000000, 0x00100000, 0x00000000, 0x00000000, + 0x00000000, 0x00800000, 0x00000100, 0x00000001, + } }, + { { /* 656 */ + 0x10000000, 0x01000000, 0x00002400, 0x00000004, + 0x00000000, 0x00000000, 0x00000020, 0x00000002, + } }, + { { /* 657 */ + 0x00010000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 658 */ + 0x00000000, 0x00002400, 0x00000000, 0x00000000, + 0x00004802, 0x00000000, 0x00000000, 0x80022000, + } }, + { { /* 659 */ + 0x00001004, 0x04208000, 0x20000020, 0x00040000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 660 */ + 0x00000000, 0x00100000, 0x40010000, 0x00000000, + 0x00080000, 0x00000000, 0x00100211, 0x00000000, + } }, + { { /* 661 */ + 0x00001400, 0x00000000, 0x00000000, 0x00000000, + 0x00610000, 0x80008c00, 0x00000000, 0x00000000, + } }, + { { /* 662 */ + 0x00000100, 0x00000040, 0x00000000, 0x00000004, + 0x00004000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 663 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000400, 0x00000000, + } }, + { { /* 664 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000210, 0x00000000, 0x00000000, + } }, + { { /* 665 */ + 0x00000000, 0x00000020, 0x00000002, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 666 */ + 0x00004000, 0x00000000, 0x00000000, 0x02000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 667 */ + 0x00000000, 0x00000000, 0x00080002, 0x01000020, + 0x00400000, 0x00200000, 0x00008000, 0x00000000, + } }, + { { /* 668 */ + 0x00000000, 0x00020000, 0x00000000, 0xc0020000, + 0x10000000, 0x00000080, 0x00000000, 0x00000000, + } }, + { { /* 669 */ + 0x00000210, 0x00000000, 0x00001000, 0x04480000, + 0x20000000, 0x00000004, 0x00800000, 0x02000000, + } }, + { { /* 670 */ + 0x00000000, 0x08006000, 0x00001000, 0x00000000, + 0x00000000, 0x00100000, 0x00000000, 0x00000400, + } }, + { { /* 671 */ + 0x00100000, 0x00000000, 0x10000000, 0x08608000, + 0x00000000, 0x00000000, 0x00080002, 0x00000000, + } }, + { { /* 672 */ + 0x00000000, 0x20000000, 0x00008020, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 673 */ + 0x00000000, 0x00000000, 0x00000000, 0x10000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 674 */ + 0x00000000, 0x00100000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 675 */ + 0x00000000, 0x00000400, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 676 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x02000000, + } }, + { { /* 677 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000080, 0x00000000, + } }, + { { /* 678 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000002, 0x00000000, 0x00000000, + } }, + { { /* 679 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00008000, 0x00000000, + } }, + { { /* 680 */ + 0x00000000, 0x00000000, 0x00000008, 0x00000000, + 0x00000000, 0x00000000, 0x00000400, 0x00000000, + } }, + { { /* 681 */ + 0x00000000, 0x00000000, 0x00220000, 0x00000004, + 0x00000000, 0x00040000, 0x00000004, 0x00000000, + } }, + { { /* 682 */ + 0x00000000, 0x00000000, 0x00001000, 0x00000080, + 0x00002000, 0x00000000, 0x00000000, 0x00004000, + } }, + { { /* 683 */ + 0x00000000, 0x00000000, 0x00000000, 0x00100000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 684 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00200000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 685 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x04000000, 0x00000000, 0x00000000, + } }, + { { /* 686 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000200, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 687 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000001, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 688 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00080000, 0x00000000, + } }, + { { /* 689 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x01000000, 0x00000000, 0x00000400, + } }, + { { /* 690 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000080, 0x00000000, 0x00000000, + } }, + { { /* 691 */ + 0x00000000, 0x00000800, 0x00000100, 0x40000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 692 */ + 0x00000000, 0x00200000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 693 */ + 0x00000000, 0x00000000, 0x01000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 694 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x04000000, 0x00000000, + } }, + { { /* 695 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00001000, 0x00000000, + } }, + { { /* 696 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000400, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 697 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x04040000, + } }, + { { /* 698 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000020, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 699 */ + 0x00000000, 0x00000000, 0x00800000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 700 */ + 0x00000000, 0x00200000, 0x40000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 701 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x20000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 702 */ + 0x00000000, 0x00000000, 0x00000000, 0x04000000, + 0x00000000, 0x00000001, 0x00000000, 0x00000000, + } }, + { { /* 703 */ + 0x00000000, 0x40000000, 0x02000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 704 */ + 0x00000000, 0x00000000, 0x00000000, 0x00080000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 705 */ + 0x00000000, 0x00000010, 0x00000000, 0x00000000, + 0x00000000, 0x20000000, 0x00000000, 0x00000000, + } }, + { { /* 706 */ + 0x00000000, 0x00000000, 0x20000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 707 */ + 0x00000080, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000004, + } }, + { { /* 708 */ + 0x00000000, 0x00000000, 0x00000000, 0x00002000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 709 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x10000001, 0x00000000, + } }, + { { /* 710 */ + 0x00008000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 711 */ + 0x00000000, 0x00000000, 0x00004040, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 712 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00042400, 0x00000000, + } }, + { { /* 713 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x02000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 714 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000080, + } }, + { { /* 715 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000020, + } }, + { { /* 716 */ + 0x00000000, 0x00000001, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 717 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00020000, 0x00000000, + } }, + { { /* 718 */ + 0x00000000, 0x00000000, 0x00002000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 719 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x01000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 720 */ + 0x00000000, 0x00040000, 0x08000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 721 */ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x00000280, 0x00000000, + } }, + { { /* 722 */ + 0x7f7b7f8b, 0xef553db4, 0xf35dfba8, 0x400b0243, + 0x8d3efb40, 0x8c2c7bf7, 0xe3fa6eff, 0xa8ed1d3a, + } }, + { { /* 723 */ + 0xcf83e602, 0x35558cf5, 0xffabe048, 0xd85992b9, + 0x2892ab18, 0x8020d7e9, 0xf583c438, 0x450ae74a, + } }, + { { /* 724 */ + 0x9714b000, 0x54007762, 0x1420d188, 0xc8c01020, + 0x00002121, 0x0c0413a8, 0x04408000, 0x082870c0, + } }, + { { /* 725 */ + 0x000408c0, 0x80000002, 0x14722b7b, 0x3bfb7924, + 0x1ae43327, 0x38ef9835, 0x28029ad1, 0xbf69a813, + } }, + { { /* 726 */ + 0x2fc665cf, 0xafc96b11, 0x5053340f, 0xa00486a2, + 0xe8090106, 0xc00e3f0f, 0x81450a88, 0xc6010010, + } }, + { { /* 727 */ + 0x26e1a161, 0xce00444b, 0xd4eec7aa, 0x85bbcadf, + 0xa5203a74, 0x8840436c, 0x8bd23f06, 0x3befff79, + } }, + { { /* 728 */ + 0xe8eff75a, 0x5b36fbcb, 0x1bfd0d49, 0x39ee0154, + 0x2e75d855, 0xa91abfd8, 0xf6bff3d7, 0xb40c67e0, + } }, + { { /* 729 */ + 0x081382c2, 0xd08bd49d, 0x1061065a, 0x59e074f2, + 0xb3128f9f, 0x6aaa0080, 0xb05e3230, 0x60ac9d7a, + } }, + { { /* 730 */ + 0xc900d303, 0x8a563098, 0x13907000, 0x18421f14, + 0x0008c060, 0x10808008, 0xec900400, 0xe6332817, + } }, + { { /* 731 */ + 0x90000758, 0x4e09f708, 0xfc83f485, 0x18c8af53, + 0x080c187c, 0x01146adf, 0xa734c80c, 0x2710a011, + } }, + { { /* 732 */ + 0x422228c5, 0x00210413, 0x41123010, 0x40001820, + 0xc60c022b, 0x10000300, 0x00220022, 0x02495810, + } }, + { { /* 733 */ + 0x9670a094, 0x1792eeb0, 0x05f2cb96, 0x23580025, + 0x42cc25de, 0x4a04cf38, 0x359f0c40, 0x8a001128, + } }, + { { /* 734 */ + 0x910a13fa, 0x10560229, 0x04200641, 0x84f00484, + 0x0c040000, 0x412c0400, 0x11541206, 0x00020a4b, + } }, + { { /* 735 */ + 0x00c00200, 0x00940000, 0xbfbb0001, 0x242b167c, + 0x7fa89bbb, 0xe3790c7f, 0xe00d10f4, 0x9f014132, + } }, + { { /* 736 */ + 0x35728652, 0xff1210b4, 0x4223cf27, 0x8602c06b, + 0x1fd33106, 0xa1aa3a0c, 0x02040812, 0x08012572, + } }, + { { /* 737 */ + 0x485040cc, 0x601062d0, 0x29001c80, 0x00109a00, + 0x22000004, 0x00800000, 0x68002020, 0x609ecbe6, + } }, + { { /* 738 */ + 0x3f73916e, 0x398260c0, 0x48301034, 0xbd5c0006, + 0xd6fb8cd1, 0x43e820e1, 0x084e0600, 0xc4d00500, + } }, + { { /* 739 */ + 0x89aa8d1f, 0x1602a6e1, 0x21ed0001, 0x1a8b3656, + 0x13a51fb7, 0x30a06502, 0x23c7b278, 0xe9226c93, + } }, + { { /* 740 */ + 0x3a74e47f, 0x98208fe3, 0x2625280e, 0xbf49bf9c, + 0xac543218, 0x1916b949, 0xb5220c60, 0x0659fbc1, + } }, + { { /* 741 */ + 0x8420e343, 0x800008d9, 0x20225500, 0x00a10184, + 0x20104800, 0x40801380, 0x00160d04, 0x80200040, + } }, + { { /* 742 */ + 0x8de7fd40, 0xe0985436, 0x091e7b8b, 0xd249fec8, + 0x8dee0611, 0xba221937, 0x9fdd77f4, 0xf0daf3ec, + } }, + { { /* 743 */ + 0xec424386, 0x26048d3f, 0xc021fa6c, 0x0cc2628e, + 0x0145d785, 0x559977ad, 0x4045e250, 0xa154260b, + } }, + { { /* 744 */ + 0x58199827, 0xa4103443, 0x411405f2, 0x07002280, + 0x426600b4, 0x15a17210, 0x41856025, 0x00000054, + } }, + { { /* 745 */ + 0x01040201, 0xcb70c820, 0x6a629320, 0x0095184c, + 0x9a8b1880, 0x3201aab2, 0x00c4d87a, 0x04c3f3e5, + } }, + { { /* 746 */ + 0xa238d44d, 0x5072a1a1, 0x84fc980a, 0x44d1c152, + 0x20c21094, 0x42104180, 0x3a000000, 0xd29d0240, + } }, + { { /* 747 */ + 0xa8b12f01, 0x2432bd40, 0xd04bd34d, 0xd0ada723, + 0x75a10a92, 0x01e9adac, 0x771f801a, 0xa01b9225, + } }, + { { /* 748 */ + 0x20cadfa1, 0x738c0602, 0x003b577f, 0x00d00bff, + 0x0088806a, 0x0029a1c4, 0x05242a05, 0x16234009, + } }, + { { /* 749 */ + 0x80056822, 0xa2112011, 0x64900004, 0x13824849, + 0x193023d5, 0x08922980, 0x88115402, 0xa0042001, + } }, + { { /* 750 */ + 0x81800400, 0x60228502, 0x0b010090, 0x12020022, + 0x00834011, 0x00001a01, 0x00000000, 0x00000000, + } }, + { { /* 751 */ + 0x00000000, 0x4684009f, 0x020012c8, 0x1a0004fc, + 0x0c4c2ede, 0x80b80402, 0x0afca826, 0x22288c02, + } }, + { { /* 752 */ + 0x8f7ba0e0, 0x2135c7d6, 0xf8b106c7, 0x62550713, + 0x8a19936e, 0xfb0e6efa, 0x48f91630, 0x7debcd2f, + } }, + { { /* 753 */ + 0x4e845892, 0x7a2e4ca0, 0x561eedea, 0x1190c649, + 0xe83a5324, 0x8124cfdb, 0x634218f1, 0x1a8a5853, + } }, + { { /* 754 */ + 0x24d37420, 0x0514aa3b, 0x89586018, 0xc0004800, + 0x91018268, 0x2cd684a4, 0xc4ba8886, 0x02100377, + } }, + { { /* 755 */ + 0x00388244, 0x404aae11, 0x510028c0, 0x15146044, + 0x10007310, 0x02480082, 0x40060205, 0x0000c003, + } }, + { { /* 756 */ + 0x0c020000, 0x02200008, 0x40009000, 0xd161b800, + 0x32744621, 0x3b8af800, 0x8b00050f, 0x2280bbd0, + } }, + { { /* 757 */ + 0x07690600, 0x00438040, 0x50005420, 0x250c41d0, + 0x83108410, 0x02281101, 0x00304008, 0x020040a1, + } }, + { { /* 758 */ + 0x20000040, 0xabe31500, 0xaa443180, 0xc624c2c6, + 0x8004ac13, 0x03d1b000, 0x4285611e, 0x1d9ff303, + } }, + { { /* 759 */ + 0x78e8440a, 0xc3925e26, 0x00852000, 0x4000b001, + 0x88424a90, 0x0c8dca04, 0x4203a705, 0x000422a1, + } }, + { { /* 760 */ + 0x0c018668, 0x10795564, 0xdea00002, 0x40c12000, + 0x5001488b, 0x04000380, 0x50040000, 0x80d0c05d, + } }, + { { /* 761 */ + 0x970aa010, 0x4dafbb20, 0x1e10d921, 0x83140460, + 0xa6d68848, 0x733fd83b, 0x497427bc, 0x92130ddc, + } }, + { { /* 762 */ + 0x8ba1142b, 0xd1392e75, 0x50503009, 0x69008808, + 0x024a49d4, 0x80164010, 0x89d7e564, 0x5316c020, + } }, + { { /* 763 */ + 0x86002b92, 0x15e0a345, 0x0c03008b, 0xe200196e, + 0x80067031, 0xa82916a5, 0x18802000, 0xe1487aac, + } }, + { { /* 764 */ + 0xb5d63207, 0x5f9132e8, 0x20e550a1, 0x10807c00, + 0x9d8a7280, 0x421f00aa, 0x02310e22, 0x04941100, + } }, + { { /* 765 */ + 0x40080022, 0x5c100010, 0xfcc80343, 0x0580a1a5, + 0x04008433, 0x6e080080, 0x81262a4b, 0x2901aad8, + } }, + { { /* 766 */ + 0x4490684d, 0xba880009, 0x00820040, 0x87d10000, + 0xb1e6215b, 0x80083161, 0xc2400800, 0xa600a069, + } }, + { { /* 767 */ + 0x4a328d58, 0x550a5d71, 0x2d579aa0, 0x4aa64005, + 0x30b12021, 0x01123fc6, 0x260a10c2, 0x50824462, + } }, + { { /* 768 */ + 0x80409880, 0x810004c0, 0x00002003, 0x38180000, + 0xf1a60200, 0x720e4434, 0x92e035a2, 0x09008101, + } }, + { { /* 769 */ + 0x00000400, 0x00008885, 0x00000000, 0x00804000, + 0x00000000, 0x00004040, 0x00000000, 0x00000000, + } }, + { { /* 770 */ + 0x00000000, 0x08000000, 0x00000082, 0x00000000, + 0x88000004, 0xe7efbfff, 0xffbfffff, 0xfdffefef, + } }, + { { /* 771 */ + 0xbffefbff, 0x057fffff, 0x85b30034, 0x42164706, + 0xe4105402, 0xb3058092, 0x81305422, 0x180b4263, + } }, + { { /* 772 */ + 0x13f5387b, 0xa9ea07e5, 0x05143c4c, 0x80020600, + 0xbd481ad9, 0xf496ee37, 0x7ec0705f, 0x355fbfb2, + } }, + { { /* 773 */ + 0x455fe644, 0x41469000, 0x063b1d40, 0xfe1362a1, + 0x39028505, 0x0c080548, 0x0000144f, 0x58183488, + } }, + { { /* 774 */ + 0xd8153077, 0x4bfbbd0e, 0x85008a90, 0xe61dc100, + 0xb386ed14, 0x639bff72, 0xd9befd92, 0x0a92887b, + } }, + { { /* 775 */ + 0x1cb2d3fe, 0x177ab980, 0xdc1782c9, 0x3980fffb, + 0x590c4260, 0x37df0f01, 0xb15094a3, 0x23070623, + } }, + { { /* 776 */ + 0x3102f85a, 0x310201f0, 0x1e820040, 0x056a3a0a, + 0x12805b84, 0xa7148002, 0xa04b2612, 0x90011069, + } }, + { { /* 777 */ + 0x848a1000, 0x3f801802, 0x42400708, 0x4e140110, + 0x180080b0, 0x0281c510, 0x10298202, 0x88000210, + } }, + { { /* 778 */ + 0x00420020, 0x11000280, 0x4413e000, 0xfe025804, + 0x30283c07, 0x04739798, 0xcb13ced1, 0x431f6210, + } }, + { { /* 779 */ + 0x55ac278d, 0xc892422e, 0x02885380, 0x78514039, + 0x8088292c, 0x2428b900, 0x080e0c41, 0x42004421, + } }, + { { /* 780 */ + 0x08680408, 0x12040006, 0x02903031, 0xe0855b3e, + 0x10442936, 0x10822814, 0x83344266, 0x531b013c, + } }, + { { /* 781 */ + 0x0e0d0404, 0x00510c22, 0xc0000012, 0x88000040, + 0x0000004a, 0x00000000, 0x5447dff6, 0x00088868, + } }, + { { /* 782 */ + 0x00000081, 0x40000000, 0x00000100, 0x02000000, + 0x00080600, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 783 */ + 0x00000080, 0x00000040, 0x00000000, 0x00001040, + 0x00000000, 0xf7fdefff, 0xfffeff7f, 0xfffffbff, + } }, + { { /* 784 */ + 0xbffffdff, 0x00ffffff, 0x042012c2, 0x07080c06, + 0x01101624, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 785 */ + 0xe0000000, 0xfffffffe, 0x7f79ffff, 0x00f928df, + 0x80120c32, 0xd53a0008, 0xecc2d858, 0x2fa89d18, + } }, + { { /* 786 */ + 0xe0109620, 0x2622d60c, 0x02060f97, 0x9055b240, + 0x501180a2, 0x04049800, 0x00004000, 0x00000000, + } }, + { { /* 787 */ + 0x00000000, 0x00000000, 0x00000000, 0xfffffbc0, + 0xdffbeffe, 0x62430b08, 0xfb3b41b6, 0x23896f74, + } }, + { { /* 788 */ + 0xecd7ae7f, 0x5960e047, 0x098fa096, 0xa030612c, + 0x2aaa090d, 0x4f7bd44e, 0x388bc4b2, 0x6110a9c6, + } }, + { { /* 789 */ + 0x42000014, 0x0202800c, 0x6485fe48, 0xe3f7d63e, + 0x0c073aa0, 0x0430e40c, 0x1002f680, 0x00000000, + } }, + { { /* 790 */ + 0x00000000, 0x00000000, 0x00000000, 0x00100000, + 0x00004000, 0x00004000, 0x00000100, 0x00000000, + } }, + { { /* 791 */ + 0x00000000, 0x40000000, 0x00000000, 0x00000400, + 0x00008000, 0x00000000, 0x00400400, 0x00000000, + } }, + { { /* 792 */ + 0x00000000, 0x40000000, 0x00000000, 0x00000800, + 0xfebdffe0, 0xffffffff, 0xfbe77f7f, 0xf7ffffbf, + } }, + { { /* 793 */ + 0xefffffff, 0xdff7ff7e, 0xfbdff6f7, 0x804fbffe, + 0x00000000, 0x00000000, 0x00000000, 0x7fffef00, + } }, + { { /* 794 */ + 0xb6f7ff7f, 0xb87e4406, 0x88313bf5, 0x00f41796, + 0x1391a960, 0x72490080, 0x0024f2f3, 0x42c88701, + } }, + { { /* 795 */ + 0x5048e3d3, 0x43052400, 0x4a4c0000, 0x10580227, + 0x01162820, 0x0014a809, 0x00000000, 0x00683ec0, + } }, + { { /* 796 */ + 0x00000000, 0x00000000, 0x00000000, 0xffe00000, + 0xfddbb7ff, 0x000000f7, 0xc72e4000, 0x00000180, + } }, + { { /* 797 */ + 0x00012000, 0x00004000, 0x00300000, 0xb4f7ffa8, + 0x03ffadf3, 0x00000120, 0x00000000, 0x00000000, + } }, + { { /* 798 */ + 0x00000000, 0x00000000, 0x00000000, 0xfffbf000, + 0xfdcf9df7, 0x15c301bf, 0x810a1827, 0x0a00a842, + } }, + { { /* 799 */ + 0x80088108, 0x18048008, 0x0012a3be, 0x00000000, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, + } }, + { { /* 800 */ + 0x00000000, 0x00000000, 0x00000000, 0x90000000, + 0xdc3769e6, 0x3dff6bff, 0xf3f9fcf8, 0x00000004, + } }, + { { /* 801 */ + 0x80000000, 0xe7eebf6f, 0x5da2dffe, 0xc00b3fd8, + 0xa00c0984, 0x69100040, 0xb912e210, 0x5a0086a5, + } }, + { { /* 802 */ + 0x02896800, 0x6a809005, 0x00030010, 0x80000000, + 0x8e001ff9, 0x00000001, 0x00000000, 0x00000000, + } }, + { { /* 803 */ + 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, + 0xffffffff, 0xffffffff, 0x003fffff, 0x00000000, + } }, +}, +{ + /* aa */ + LEAF( 0, 0), + /* ab */ + LEAF( 1, 1), + /* ae */ + LEAF( 2, 2), + /* af */ + LEAF( 3, 3), LEAF( 3, 4), + /* agr */ + LEAF( 5, 5), + /* aho */ + LEAF( 6, 6), + /* ak */ + LEAF( 7, 7), LEAF( 7, 8), LEAF( 7, 9), LEAF( 7, 10), + LEAF( 7, 11), + /* akk */ + LEAF( 12, 12), LEAF( 12, 12), LEAF( 12, 12), LEAF( 12, 13), + LEAF( 12, 14), LEAF( 12, 15), + /* am */ + LEAF( 18, 16), LEAF( 18, 17), + /* an */ + LEAF( 20, 18), + /* anp */ + LEAF( 21, 19), + /* ar */ + LEAF( 22, 20), + /* arc */ + LEAF( 23, 21), + /* as */ + LEAF( 24, 22), + /* ast */ + LEAF( 25, 18), LEAF( 25, 23), + /* av */ + LEAF( 27, 24), + /* ay */ + LEAF( 28, 25), + /* ayc */ + LEAF( 29, 26), + /* az_az */ + LEAF( 30, 27), LEAF( 30, 28), LEAF( 30, 29), + /* az_ir */ + LEAF( 33, 30), + /* ba */ + LEAF( 34, 31), + /* ban */ + LEAF( 35, 32), + /* bax */ + LEAF( 36, 33), + /* be */ + LEAF( 37, 34), + /* bem */ + LEAF( 38, 35), + /* ber_dz */ + LEAF( 39, 35), LEAF( 39, 36), LEAF( 39, 37), LEAF( 39, 38), + /* ber_ma */ + LEAF( 43, 39), + /* bg */ + LEAF( 44, 40), + /* bi */ + LEAF( 45, 41), + /* bin */ + LEAF( 46, 42), LEAF( 46, 43), LEAF( 46, 44), + /* bku */ + LEAF( 49, 45), + /* blt */ + LEAF( 50, 46), + /* bm */ + LEAF( 51, 35), LEAF( 51, 47), LEAF( 51, 48), + /* bn */ + LEAF( 54, 49), + /* bo */ + LEAF( 55, 50), + /* br */ + LEAF( 56, 51), + /* brx */ + LEAF( 57, 52), + /* bs */ + LEAF( 58, 35), LEAF( 58, 53), + /* bua */ + LEAF( 60, 54), + /* byn */ + LEAF( 61, 55), LEAF( 61, 56), + /* ca */ + LEAF( 63, 57), LEAF( 63, 58), + /* ccp */ + LEAF( 65, 59), + /* ch */ + LEAF( 66, 60), + /* chm */ + LEAF( 67, 61), + /* chr */ + LEAF( 68, 62), + /* cjm */ + LEAF( 69, 63), + /* ckb */ + LEAF( 70, 64), + /* cmn */ + LEAF( 71, 65), LEAF( 71, 66), LEAF( 71, 67), LEAF( 71, 68), + LEAF( 71, 69), LEAF( 71, 70), LEAF( 71, 71), LEAF( 71, 72), + LEAF( 71, 73), LEAF( 71, 74), LEAF( 71, 75), LEAF( 71, 76), + LEAF( 71, 77), LEAF( 71, 78), LEAF( 71, 79), LEAF( 71, 80), + LEAF( 71, 81), LEAF( 71, 82), LEAF( 71, 83), LEAF( 71, 84), + LEAF( 71, 85), LEAF( 71, 86), LEAF( 71, 87), LEAF( 71, 88), + LEAF( 71, 89), LEAF( 71, 90), LEAF( 71, 91), LEAF( 71, 92), + LEAF( 71, 93), LEAF( 71, 94), LEAF( 71, 95), LEAF( 71, 96), + LEAF( 71, 97), LEAF( 71, 98), LEAF( 71, 99), LEAF( 71,100), + LEAF( 71,101), LEAF( 71,102), LEAF( 71,103), LEAF( 71,104), + LEAF( 71,105), LEAF( 71,106), LEAF( 71,107), LEAF( 71,108), + LEAF( 71,109), LEAF( 71,110), LEAF( 71,111), LEAF( 71,112), + LEAF( 71,113), LEAF( 71,114), LEAF( 71,115), LEAF( 71,116), + LEAF( 71,117), LEAF( 71,118), LEAF( 71,119), LEAF( 71,120), + LEAF( 71,121), LEAF( 71,122), LEAF( 71,123), LEAF( 71,124), + LEAF( 71,125), LEAF( 71,126), LEAF( 71,127), LEAF( 71,128), + LEAF( 71,129), LEAF( 71,130), LEAF( 71,131), LEAF( 71,132), + LEAF( 71,133), LEAF( 71,134), LEAF( 71,135), LEAF( 71,136), + LEAF( 71,137), LEAF( 71,138), LEAF( 71,139), LEAF( 71,140), + LEAF( 71,141), LEAF( 71,142), LEAF( 71,143), LEAF( 71,144), + LEAF( 71,145), LEAF( 71,146), LEAF( 71,147), + /* co */ + LEAF(154,148), LEAF(154,149), + /* cop */ + LEAF(156,150), LEAF(156,151), + /* crh */ + LEAF(158,152), LEAF(158,153), + /* cs */ + LEAF(160,154), LEAF(160,155), + /* csb */ + LEAF(162,156), LEAF(162,157), + /* cu */ + LEAF(164,158), + /* cv */ + LEAF(165,159), LEAF(165,160), + /* cy */ + LEAF(167,161), LEAF(167,162), LEAF(167,163), + /* da */ + LEAF(170,164), + /* de */ + LEAF(171,165), + /* dmf */ + LEAF(172,166), + /* doi */ + LEAF(173,167), + /* dv */ + LEAF(174,168), + /* ecy */ + LEAF(175,169), + /* ee */ + LEAF(176, 42), LEAF(176,170), LEAF(176,171), LEAF(176,172), + /* egy */ + LEAF(180, 12), LEAF(180, 12), LEAF(180, 12), LEAF(180, 12), + LEAF(180,173), + /* eky */ + LEAF(185,173), + /* el */ + LEAF(186,174), + /* en */ + LEAF(187,175), + /* eo */ + LEAF(188, 35), LEAF(188,176), + /* et */ + LEAF(190,177), LEAF(190,178), + /* ett */ + LEAF(192,179), + /* eu */ + LEAF(193,180), + /* ff */ + LEAF(194, 35), LEAF(194,181), LEAF(194,182), + /* fi */ + LEAF(197,183), LEAF(197,178), + /* fil */ + LEAF(199,184), + /* fo */ + LEAF(200,185), + /* fur */ + LEAF(201,186), + /* fy */ + LEAF(202,187), + /* ga */ + LEAF(203,188), LEAF(203,189), LEAF(203,190), + /* gd */ + LEAF(206,191), + /* gez */ + LEAF(207,192), LEAF(207,193), + /* gmy */ + LEAF(209,194), + /* gn */ + LEAF(210,195), LEAF(210,196), LEAF(210,197), + /* got */ + LEAF(213,198), + /* gu */ + LEAF(214,199), + /* gv */ + LEAF(215,200), + /* ha */ + LEAF(216, 35), LEAF(216,201), LEAF(216,202), + /* haw */ + LEAF(219, 35), LEAF(219,203), LEAF(219,204), + /* he */ + LEAF(222,205), + /* hlu */ + LEAF(223, 12), LEAF(223, 12), LEAF(223,206), + /* hmd */ + LEAF(226,207), + /* hnn */ + LEAF(227,208), + /* hoc */ + LEAF(228,209), + /* hsb */ + LEAF(229,210), LEAF(229,211), + /* ht */ + LEAF(231,212), + /* hu */ + LEAF(232,213), LEAF(232,214), + /* hy */ + LEAF(234,215), + /* hz */ + LEAF(235, 35), LEAF(235,216), LEAF(235,217), + /* id */ + LEAF(238,218), + /* ie */ + LEAF(239,154), + /* ig */ + LEAF(240, 35), LEAF(240,219), + /* ii */ + LEAF(242, 12), LEAF(242, 12), LEAF(242, 12), LEAF(242, 12), + LEAF(242,220), + /* ik */ + LEAF(247,221), + /* is */ + LEAF(248,222), + /* it */ + LEAF(249,223), + /* iu */ + LEAF(250,224), LEAF(250,225), LEAF(250,226), + /* ja */ + LEAF(253,227), LEAF(253,228), LEAF(253,229), LEAF(253,230), + LEAF(253,231), LEAF(253,232), LEAF(253,233), LEAF(253,234), + LEAF(253,235), LEAF(253,236), LEAF(253,237), LEAF(253,238), + LEAF(253,239), LEAF(253,240), LEAF(253,241), LEAF(253,242), + LEAF(253,243), LEAF(253,244), LEAF(253,245), LEAF(253,246), + LEAF(253,247), LEAF(253,248), LEAF(253,249), LEAF(253,250), + LEAF(253,251), LEAF(253,252), LEAF(253,253), LEAF(253,254), + LEAF(253,255), LEAF(253,256), LEAF(253,257), LEAF(253,258), + LEAF(253,259), LEAF(253,260), LEAF(253,261), LEAF(253,262), + LEAF(253,263), LEAF(253,264), LEAF(253,265), LEAF(253,266), + LEAF(253,267), LEAF(253,268), LEAF(253,269), LEAF(253,270), + LEAF(253,271), LEAF(253,272), LEAF(253,273), LEAF(253,274), + LEAF(253,275), LEAF(253,276), LEAF(253,277), LEAF(253,278), + LEAF(253,279), LEAF(253,280), LEAF(253,281), LEAF(253,282), + LEAF(253,283), LEAF(253,284), LEAF(253,285), LEAF(253,286), + LEAF(253,287), LEAF(253,288), LEAF(253,289), LEAF(253,290), + LEAF(253,291), LEAF(253,292), LEAF(253,293), LEAF(253,294), + LEAF(253,295), LEAF(253,296), LEAF(253,297), LEAF(253,298), + LEAF(253,299), LEAF(253,300), LEAF(253,301), LEAF(253,302), + LEAF(253,303), LEAF(253,304), LEAF(253,305), LEAF(253,306), + LEAF(253,307), LEAF(253,308), LEAF(253,309), + /* jv */ + LEAF(336,310), + /* ka */ + LEAF(337,311), + /* kaa */ + LEAF(338,312), + /* kaw */ + LEAF(339,313), + /* khb */ + LEAF(340,314), + /* ki */ + LEAF(341, 35), LEAF(341,315), + /* kk */ + LEAF(343,316), + /* kl */ + LEAF(344,317), LEAF(344,318), + /* km */ + LEAF(346,319), + /* kn */ + LEAF(347,320), + /* ko */ + LEAF(348,321), LEAF(348,322), LEAF(348,323), LEAF(348,324), + LEAF(348,325), LEAF(348,326), LEAF(348,327), LEAF(348,328), + LEAF(348,329), LEAF(348,330), LEAF(348,331), LEAF(348,332), + LEAF(348,333), LEAF(348,334), LEAF(348,335), LEAF(348,336), + LEAF(348,337), LEAF(348,338), LEAF(348,339), LEAF(348,340), + LEAF(348,341), LEAF(348,342), LEAF(348,343), LEAF(348,344), + LEAF(348,345), LEAF(348,346), LEAF(348,347), LEAF(348,348), + LEAF(348,349), LEAF(348,350), LEAF(348,351), LEAF(348,352), + LEAF(348,353), LEAF(348,354), LEAF(348,355), LEAF(348,356), + LEAF(348,357), LEAF(348,358), LEAF(348,359), LEAF(348,360), + LEAF(348,361), LEAF(348,362), LEAF(348,363), LEAF(348,364), + LEAF(348,365), + /* kr */ + LEAF(393, 35), LEAF(393,366), LEAF(393,367), + /* ks */ + LEAF(396,368), + /* ku_am */ + LEAF(397,369), LEAF(397,370), + /* ku_tr */ + LEAF(399,371), LEAF(399,372), + /* kum */ + LEAF(401,373), + /* kv */ + LEAF(402,374), + /* kw */ + LEAF(403, 35), LEAF(403,203), LEAF(403,375), + /* ky */ + LEAF(406,376), + /* la */ + LEAF(407, 35), LEAF(407,377), + /* lah */ + LEAF(409,378), + /* lb */ + LEAF(410,379), + /* lep */ + LEAF(411,380), + /* lg */ + LEAF(412, 35), LEAF(412,381), + /* li */ + LEAF(414,382), + /* lif */ + LEAF(415,383), + /* lij */ + LEAF(416,384), + /* lis */ + LEAF(417,385), + /* ln */ + LEAF(418,386), LEAF(418,387), LEAF(418, 9), LEAF(418,388), + /* lo */ + LEAF(422,389), + /* lt */ + LEAF(423, 35), LEAF(423,390), + /* lv */ + LEAF(425, 35), LEAF(425,391), + /* mg */ + LEAF(427,392), + /* mh */ + LEAF(428, 35), LEAF(428,393), + /* mi */ + LEAF(430, 35), LEAF(430,203), LEAF(430,394), + /* mid */ + LEAF(433,395), + /* miq */ + LEAF(434,396), LEAF(434,196), LEAF(434,397), + /* mk */ + LEAF(437,398), + /* ml */ + LEAF(438,399), + /* mn_cn */ + LEAF(439,400), + /* mn_mn */ + LEAF(440,401), + /* mni */ + LEAF(441,402), LEAF(441,403), + /* mnw */ + LEAF(443,404), + /* mo */ + LEAF(444,405), LEAF(444,159), LEAF(444,406), LEAF(444,373), + /* mro */ + LEAF(448,407), + /* mt */ + LEAF(449,408), LEAF(449,409), + /* na */ + LEAF(451, 7), LEAF(451,410), + /* nan */ + LEAF(453,175), LEAF(453, 65), LEAF(453, 66), LEAF(453, 67), + LEAF(453, 68), LEAF(453, 69), LEAF(453, 70), LEAF(453, 71), + LEAF(453, 72), LEAF(453, 73), LEAF(453, 74), LEAF(453, 75), + LEAF(453, 76), LEAF(453, 77), LEAF(453, 78), LEAF(453, 79), + LEAF(453, 80), LEAF(453, 81), LEAF(453, 82), LEAF(453, 83), + LEAF(453, 84), LEAF(453, 85), LEAF(453, 86), LEAF(453, 87), + LEAF(453, 88), LEAF(453, 89), LEAF(453, 90), LEAF(453, 91), + LEAF(453, 92), LEAF(453, 93), LEAF(453, 94), LEAF(453, 95), + LEAF(453, 96), LEAF(453, 97), LEAF(453, 98), LEAF(453, 99), + LEAF(453,100), LEAF(453,101), LEAF(453,102), LEAF(453,103), + LEAF(453,104), LEAF(453,105), LEAF(453,106), LEAF(453,107), + LEAF(453,108), LEAF(453,109), LEAF(453,110), LEAF(453,111), + LEAF(453,112), LEAF(453,113), LEAF(453,114), LEAF(453,115), + LEAF(453,116), LEAF(453,117), LEAF(453,118), LEAF(453,119), + LEAF(453,120), LEAF(453,121), LEAF(453,122), LEAF(453,123), + LEAF(453,124), LEAF(453,125), LEAF(453,126), LEAF(453,127), + LEAF(453,128), LEAF(453,129), LEAF(453,130), LEAF(453,131), + LEAF(453,132), LEAF(453,133), LEAF(453,134), LEAF(453,135), + LEAF(453,136), LEAF(453,137), LEAF(453,138), LEAF(453,139), + LEAF(453,140), LEAF(453,141), LEAF(453,142), LEAF(453,143), + LEAF(453,144), LEAF(453,145), LEAF(453,146), LEAF(453,147), + /* nb */ + LEAF(537,411), + /* ne */ + LEAF(538,412), + /* nhn */ + LEAF(539, 18), LEAF(539,413), + /* niu */ + LEAF(541,175), LEAF(541,414), + /* nl */ + LEAF(543,415), + /* nn */ + LEAF(544,416), + /* nnp */ + LEAF(545,417), + /* nqo */ + LEAF(546,418), + /* nso */ + LEAF(547,419), LEAF(547,420), + /* nv */ + LEAF(549,421), LEAF(549,422), LEAF(549,423), LEAF(549,424), + /* ny */ + LEAF(553, 35), LEAF(553,425), + /* oc */ + LEAF(555,426), + /* or */ + LEAF(556,427), + /* osa */ + LEAF(557,428), + /* ota */ + LEAF(558,429), + /* otk */ + LEAF(559,430), + /* oui */ + LEAF(560,431), + /* pa */ + LEAF(561,432), + /* pal */ + LEAF(562,433), + /* pap_an */ + LEAF(563,434), + /* pap_aw */ + LEAF(564,435), + /* peo */ + LEAF(565,436), + /* pgd */ + LEAF(566,437), + /* pgl */ + LEAF(567,438), + /* phn */ + LEAF(568,439), + /* pl */ + LEAF(569,210), LEAF(569,440), + /* ps_af */ + LEAF(571,441), + /* ps_pk */ + LEAF(572,442), + /* pt */ + LEAF(573,443), + /* qu */ + LEAF(574,435), LEAF(574,444), + /* rhg */ + LEAF(576,445), + /* rif */ + LEAF(577,175), LEAF(577,446), LEAF(577, 37), LEAF(577,447), + /* rm */ + LEAF(581,448), + /* ro */ + LEAF(582,405), LEAF(582,159), LEAF(582,406), + /* sah */ + LEAF(585,449), + /* sam */ + LEAF(586,450), + /* sat */ + LEAF(587,451), + /* sc */ + LEAF(588,452), + /* sco */ + LEAF(589, 35), LEAF(589,453), LEAF(589,454), + /* sd */ + LEAF(592,455), + /* se */ + LEAF(593,456), LEAF(593,457), + /* sg */ + LEAF(595,458), + /* sgs */ + LEAF(596,459), LEAF(596,460), LEAF(596,461), + /* sh */ + LEAF(599, 35), LEAF(599, 53), LEAF(599,462), + /* shs */ + LEAF(602,463), LEAF(602,464), + /* si */ + LEAF(604,465), + /* sid */ + LEAF(605,466), LEAF(605, 17), + /* sk */ + LEAF(607,467), LEAF(607,468), + /* sm */ + LEAF(609, 35), LEAF(609,204), + /* sma */ + LEAF(611,469), + /* smj */ + LEAF(612,470), + /* smn */ + LEAF(613,471), LEAF(613,472), + /* sms */ + LEAF(615,473), LEAF(615,474), LEAF(615,475), + /* so */ + LEAF(618,476), + /* sog */ + LEAF(619,477), + /* sq */ + LEAF(620,478), + /* sr */ + LEAF(621,479), + /* su */ + LEAF(622,480), LEAF(622,481), + /* suz */ + LEAF(624,482), + /* sv */ + LEAF(625,483), + /* syr */ + LEAF(626,484), + /* szl */ + LEAF(627,485), LEAF(627,486), + /* ta */ + LEAF(629,487), + /* tbw */ + LEAF(630,488), + /* tdd */ + LEAF(631,489), + /* te */ + LEAF(632,490), + /* tg */ + LEAF(633,491), + /* th */ + LEAF(634,492), + /* tig */ + LEAF(635,493), LEAF(635, 56), + /* tk */ + LEAF(637,494), LEAF(637,495), + /* tl */ + LEAF(639,496), + /* tr */ + LEAF(640,497), LEAF(640,153), + /* tt */ + LEAF(642,498), + /* txg */ + LEAF(643, 12), LEAF(643, 12), LEAF(643, 12), LEAF(643, 12), + LEAF(643, 12), LEAF(643, 12), LEAF(643, 12), LEAF(643, 12), + LEAF(643, 12), LEAF(643, 12), LEAF(643, 12), LEAF(643, 12), + LEAF(643, 12), LEAF(643, 12), LEAF(643, 12), LEAF(643, 12), + LEAF(643, 12), LEAF(643, 12), LEAF(643, 12), LEAF(643, 12), + LEAF(643, 12), LEAF(643, 12), LEAF(643, 12), LEAF(643,499), + LEAF(643, 12), LEAF(643, 12), LEAF(643, 12), LEAF(643,500), + /* ty */ + LEAF(671,501), LEAF(671,203), LEAF(671,423), + /* ug */ + LEAF(674,502), + /* uga */ + LEAF(675,503), + /* uk */ + LEAF(676,504), + /* und_zmth */ + LEAF(677,505), LEAF(677,506), LEAF(677,507), LEAF(677,508), + LEAF(677,509), LEAF(677,510), LEAF(677,511), LEAF(677,512), + LEAF(677,513), LEAF(677,514), LEAF(677,515), LEAF(677,516), + /* und_zsye */ + LEAF(689,517), LEAF(689,518), LEAF(689,519), LEAF(689,520), + LEAF(689,521), LEAF(689,522), LEAF(689,523), LEAF(689,524), + LEAF(689,525), LEAF(689,526), LEAF(689,527), LEAF(689,528), + /* vai */ + LEAF(701, 12), LEAF(701,529), + /* ve */ + LEAF(703, 35), LEAF(703,530), + /* vi */ + LEAF(705,531), LEAF(705,532), LEAF(705,533), LEAF(705,534), + /* vo */ + LEAF(709,535), + /* vot */ + LEAF(710,536), LEAF(710,178), + /* wa */ + LEAF(712,537), + /* wen */ + LEAF(713,210), LEAF(713,538), + /* wo */ + LEAF(715,539), LEAF(715,381), + /* xag */ + LEAF(717,540), + /* xco */ + LEAF(718,541), + /* xcr */ + LEAF(719,542), + /* xlc */ + LEAF(720,438), + /* xld */ + LEAF(721,543), + /* xmr */ + LEAF(722,544), + /* xna */ + LEAF(723,545), + /* xpr */ + LEAF(724,546), + /* xsa */ + LEAF(725,547), + /* xzh */ + LEAF(726,548), + /* yap */ + LEAF(727,549), + /* yo */ + LEAF(728,550), LEAF(728,551), LEAF(728,552), LEAF(728,553), + /* yue */ + LEAF(732,554), LEAF(732,555), LEAF(732,556), LEAF(732,557), + LEAF(732,558), LEAF(732,559), LEAF(732,560), LEAF(732,561), + LEAF(732,562), LEAF(732,563), LEAF(732,564), LEAF(732,565), + LEAF(732,566), LEAF(732,567), LEAF(732,568), LEAF(732,569), + LEAF(732,570), LEAF(732,571), LEAF(732,572), LEAF(732,573), + LEAF(732,574), LEAF(732,575), LEAF(732,576), LEAF(732,577), + LEAF(732,578), LEAF(732,579), LEAF(732,580), LEAF(732,581), + LEAF(732,582), LEAF(732,583), LEAF(732,584), LEAF(732,585), + LEAF(732,586), LEAF(732,587), LEAF(732,588), LEAF(732,589), + LEAF(732,590), LEAF(732,591), LEAF(732,592), LEAF(732,593), + LEAF(732,594), LEAF(732,595), LEAF(732,596), LEAF(732,597), + LEAF(732,598), LEAF(732,599), LEAF(732,600), LEAF(732,601), + LEAF(732,602), LEAF(732,603), LEAF(732,604), LEAF(732,605), + LEAF(732,606), LEAF(732,607), LEAF(732,608), LEAF(732,609), + LEAF(732,610), LEAF(732,611), LEAF(732,612), LEAF(732,613), + LEAF(732,614), LEAF(732,615), LEAF(732,616), LEAF(732,617), + LEAF(732,618), LEAF(732,619), LEAF(732,620), LEAF(732,621), + LEAF(732,622), LEAF(732,623), LEAF(732,624), LEAF(732,625), + LEAF(732,626), LEAF(732,627), LEAF(732,628), LEAF(732,629), + LEAF(732,630), LEAF(732,631), LEAF(732,632), LEAF(732,633), + LEAF(732,634), LEAF(732,635), LEAF(732,636), LEAF(732,637), + LEAF(732,638), LEAF(732,639), LEAF(732,640), LEAF(732,641), + LEAF(732,642), LEAF(732,643), LEAF(732,644), LEAF(732,645), + LEAF(732,646), LEAF(732,647), LEAF(732,648), LEAF(732,649), + LEAF(732,650), LEAF(732,651), LEAF(732,652), LEAF(732,653), + LEAF(732,654), LEAF(732,655), LEAF(732,656), LEAF(732,657), + LEAF(732,658), LEAF(732,659), LEAF(732,660), LEAF(732,661), + LEAF(732,662), LEAF(732,663), LEAF(732,664), LEAF(732,665), + LEAF(732,666), LEAF(732,667), LEAF(732,668), LEAF(732,669), + LEAF(732,670), LEAF(732,671), LEAF(732,672), LEAF(732,673), + LEAF(732,674), LEAF(732,675), LEAF(732,676), LEAF(732,677), + LEAF(732,678), LEAF(732,679), LEAF(732,680), LEAF(732,681), + LEAF(732,682), LEAF(732,683), LEAF(732,506), LEAF(732,684), + LEAF(732,685), LEAF(732,453), LEAF(732,686), LEAF(732,687), + LEAF(732,688), LEAF(732,689), LEAF(732,690), LEAF(732,691), + LEAF(732,692), LEAF(732, 4), LEAF(732,693), LEAF(732,694), + LEAF(732,695), LEAF(732,696), LEAF(732,697), LEAF(732,698), + LEAF(732,683), LEAF(732,699), LEAF(732,700), LEAF(732,701), + LEAF(732,702), LEAF(732,703), LEAF(732,704), LEAF(732,705), + LEAF(732,706), LEAF(732,707), LEAF(732,708), LEAF(732,709), + LEAF(732,710), LEAF(732,711), LEAF(732,712), LEAF(732,713), + LEAF(732,714), LEAF(732,715), LEAF(732,716), LEAF(732,717), + LEAF(732,718), LEAF(732,719), LEAF(732,720), + /* zh_cn */ + LEAF(903,721), LEAF(903,722), LEAF(903,723), LEAF(903,724), + LEAF(903,725), LEAF(903,726), LEAF(903,727), LEAF(903,728), + LEAF(903,729), LEAF(903,730), LEAF(903,731), LEAF(903,732), + LEAF(903,733), LEAF(903,734), LEAF(903,735), LEAF(903,736), + LEAF(903,737), LEAF(903,738), LEAF(903,739), LEAF(903,740), + LEAF(903,741), LEAF(903,742), LEAF(903,743), LEAF(903,744), + LEAF(903,745), LEAF(903,746), LEAF(903,747), LEAF(903,748), + LEAF(903,749), LEAF(903,750), LEAF(903,751), LEAF(903,752), + LEAF(903,753), LEAF(903,754), LEAF(903,755), LEAF(903,756), + LEAF(903,757), LEAF(903,758), LEAF(903,759), LEAF(903,760), + LEAF(903,761), LEAF(903,762), LEAF(903,763), LEAF(903,764), + LEAF(903,765), LEAF(903,766), LEAF(903,767), LEAF(903,768), + LEAF(903,769), LEAF(903,770), LEAF(903,771), LEAF(903,772), + LEAF(903,773), LEAF(903,774), LEAF(903,775), LEAF(903,776), + LEAF(903,777), LEAF(903,778), LEAF(903,779), LEAF(903,780), + LEAF(903,781), LEAF(903,782), LEAF(903,783), LEAF(903,784), + LEAF(903,785), LEAF(903,786), LEAF(903,787), LEAF(903,788), + LEAF(903,789), LEAF(903,790), LEAF(903,791), LEAF(903,792), + LEAF(903,793), LEAF(903,794), LEAF(903,795), LEAF(903,796), + LEAF(903,797), LEAF(903,798), LEAF(903,799), LEAF(903,800), + LEAF(903,801), LEAF(903,802), + /* zkt */ + LEAF(985, 12), LEAF(985,803), +}, +{ + /* aa */ + 0x0000, + /* ab */ + 0x0004, + /* ae */ + 0x010b, + /* af */ + 0x0000, 0x0001, + /* agr */ + 0x0000, + /* aho */ + 0x0117, + /* ak */ + 0x0000, 0x0001, 0x0002, 0x0003, 0x001e, + /* akk */ + 0x0120, 0x0121, 0x0122, 0x0123, 0x0124, 0x0125, + /* am */ + 0x0012, 0x0013, + /* an */ + 0x0000, + /* anp */ + 0x0009, + /* ar */ + 0x0006, + /* arc */ + 0x0108, + /* as */ + 0x0009, + /* ast */ + 0x0000, 0x001e, + /* av */ + 0x0004, + /* ay */ + 0x0000, + /* ayc */ + 0x0000, + /* az_az */ + 0x0000, 0x0001, 0x0002, + /* az_ir */ + 0x0006, + /* ba */ + 0x0004, + /* ban */ + 0x001b, + /* bax */ + 0x00a6, + /* be */ + 0x0004, + /* bem */ + 0x0000, + /* ber_dz */ + 0x0000, 0x0001, 0x0002, 0x001e, + /* ber_ma */ + 0x002d, + /* bg */ + 0x0004, + /* bi */ + 0x0000, + /* bin */ + 0x0000, 0x0003, 0x001e, + /* bku */ + 0x0017, + /* blt */ + 0x00aa, + /* bm */ + 0x0000, 0x0001, 0x0002, + /* bn */ + 0x0009, + /* bo */ + 0x000f, + /* br */ + 0x0000, + /* brx */ + 0x0009, + /* bs */ + 0x0000, 0x0001, + /* bua */ + 0x0004, + /* byn */ + 0x0012, 0x0013, + /* ca */ + 0x0000, 0x0001, + /* ccp */ + 0x0111, + /* ch */ + 0x0000, + /* chm */ + 0x0004, + /* chr */ + 0x0013, + /* cjm */ + 0x00aa, + /* ckb */ + 0x0006, + /* cmn */ + 0x004e, 0x004f, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, + 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, + 0x005e, 0x005f, 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, + 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, + 0x006e, 0x006f, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, + 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, + 0x007e, 0x007f, 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, + 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, + 0x008e, 0x008f, 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, + 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, + 0x009e, 0x009f, 0x00fa, + /* co */ + 0x0000, 0x0001, + /* cop */ + 0x0003, 0x002c, + /* crh */ + 0x0000, 0x0001, + /* cs */ + 0x0000, 0x0001, + /* csb */ + 0x0000, 0x0001, + /* cu */ + 0x0004, + /* cv */ + 0x0001, 0x0004, + /* cy */ + 0x0000, 0x0001, 0x001e, + /* da */ + 0x0000, + /* de */ + 0x0000, + /* dmf */ + 0x016e, + /* doi */ + 0x0009, + /* dv */ + 0x0007, + /* ecy */ + 0x0108, + /* ee */ + 0x0000, 0x0001, 0x0002, 0x0003, + /* egy */ + 0x0130, 0x0131, 0x0132, 0x0133, 0x0134, + /* eky */ + 0x00a9, + /* el */ + 0x0003, + /* en */ + 0x0000, + /* eo */ + 0x0000, 0x0001, + /* et */ + 0x0000, 0x0001, + /* ett */ + 0x0103, + /* eu */ + 0x0000, + /* ff */ + 0x0000, 0x0001, 0x0002, + /* fi */ + 0x0000, 0x0001, + /* fil */ + 0x0000, + /* fo */ + 0x0000, + /* fur */ + 0x0000, + /* fy */ + 0x0000, + /* ga */ + 0x0000, 0x0001, 0x001e, + /* gd */ + 0x0000, + /* gez */ + 0x0012, 0x0013, + /* gmy */ + 0x0100, + /* gn */ + 0x0000, 0x0001, 0x001e, + /* got */ + 0x0103, + /* gu */ + 0x000a, + /* gv */ + 0x0000, + /* ha */ + 0x0000, 0x0001, 0x0002, + /* haw */ + 0x0000, 0x0001, 0x0002, + /* he */ + 0x0005, + /* hlu */ + 0x0144, 0x0145, 0x0146, + /* hmd */ + 0x016f, + /* hnn */ + 0x0017, + /* hoc */ + 0x0118, + /* hsb */ + 0x0000, 0x0001, + /* ht */ + 0x0000, + /* hu */ + 0x0000, 0x0001, + /* hy */ + 0x0005, + /* hz */ + 0x0000, 0x0003, 0x001e, + /* id */ + 0x0000, + /* ie */ + 0x0000, + /* ig */ + 0x0000, 0x001e, + /* ii */ + 0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, + /* ik */ + 0x0004, + /* is */ + 0x0000, + /* it */ + 0x0000, + /* iu */ + 0x0014, 0x0015, 0x0016, + /* ja */ + 0x0030, 0x004e, 0x004f, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, + 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, + 0x005d, 0x005e, 0x005f, 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, + 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, + 0x006d, 0x006e, 0x006f, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, + 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, + 0x007d, 0x007e, 0x007f, 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, + 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, + 0x008d, 0x008e, 0x008f, 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, + 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, + 0x009d, 0x009e, 0x009f, + /* jv */ + 0x00a9, + /* ka */ + 0x0010, + /* kaa */ + 0x0004, + /* kaw */ + 0x011f, + /* khb */ + 0x0019, + /* ki */ + 0x0000, 0x0001, + /* kk */ + 0x0004, + /* kl */ + 0x0000, 0x0001, + /* km */ + 0x0017, + /* kn */ + 0x000c, + /* ko */ + 0x0031, 0x00ac, 0x00ad, 0x00ae, 0x00af, 0x00b0, 0x00b1, 0x00b2, + 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00ba, + 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf, 0x00c0, 0x00c1, 0x00c2, + 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, + 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 0x00d0, 0x00d1, 0x00d2, + 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, + /* kr */ + 0x0000, 0x0001, 0x0002, + /* ks */ + 0x0006, + /* ku_am */ + 0x0004, 0x0005, + /* ku_tr */ + 0x0000, 0x0001, + /* kum */ + 0x0004, + /* kv */ + 0x0004, + /* kw */ + 0x0000, 0x0001, 0x0002, + /* ky */ + 0x0004, + /* la */ + 0x0000, 0x0001, + /* lah */ + 0x0006, + /* lb */ + 0x0000, + /* lep */ + 0x001c, + /* lg */ + 0x0000, 0x0001, + /* li */ + 0x0000, + /* lif */ + 0x0019, + /* lij */ + 0x0000, + /* lis */ + 0x00a4, + /* ln */ + 0x0000, 0x0001, 0x0002, 0x0003, + /* lo */ + 0x000e, + /* lt */ + 0x0000, 0x0001, + /* lv */ + 0x0000, 0x0001, + /* mg */ + 0x0000, + /* mh */ + 0x0000, 0x0001, + /* mi */ + 0x0000, 0x0001, 0x001e, + /* mid */ + 0x0008, + /* miq */ + 0x0000, 0x0001, 0x001e, + /* mk */ + 0x0004, + /* ml */ + 0x000d, + /* mn_cn */ + 0x0018, + /* mn_mn */ + 0x0004, + /* mni */ + 0x00aa, 0x00ab, + /* mnw */ + 0x0010, + /* mo */ + 0x0000, 0x0001, 0x0002, 0x0004, + /* mro */ + 0x016a, + /* mt */ + 0x0000, 0x0001, + /* na */ + 0x0000, 0x0001, + /* nan */ + 0x0000, 0x004e, 0x004f, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, + 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, + 0x005d, 0x005e, 0x005f, 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, + 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, + 0x006d, 0x006e, 0x006f, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, + 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, + 0x007d, 0x007e, 0x007f, 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, + 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, + 0x008d, 0x008e, 0x008f, 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, + 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, + 0x009d, 0x009e, 0x009f, 0x00fa, + /* nb */ + 0x0000, + /* ne */ + 0x0009, + /* nhn */ + 0x0000, 0x0001, + /* niu */ + 0x0000, 0x0001, + /* nl */ + 0x0000, + /* nn */ + 0x0000, + /* nnp */ + 0x01e2, + /* nqo */ + 0x0007, + /* nso */ + 0x0000, 0x0001, + /* nv */ + 0x0000, 0x0001, 0x0002, 0x0003, + /* ny */ + 0x0000, 0x0001, + /* oc */ + 0x0000, + /* or */ + 0x000b, + /* osa */ + 0x0104, + /* ota */ + 0x0006, + /* otk */ + 0x010c, + /* oui */ + 0x010f, + /* pa */ + 0x000a, + /* pal */ + 0x010b, + /* pap_an */ + 0x0000, + /* pap_aw */ + 0x0000, + /* peo */ + 0x0103, + /* pgd */ + 0x010a, + /* pgl */ + 0x0016, + /* phn */ + 0x0109, + /* pl */ + 0x0000, 0x0001, + /* ps_af */ + 0x0006, + /* ps_pk */ + 0x0006, + /* pt */ + 0x0000, + /* qu */ + 0x0000, 0x0002, + /* rhg */ + 0x010d, + /* rif */ + 0x0000, 0x0001, 0x0002, 0x001e, + /* rm */ + 0x0000, + /* ro */ + 0x0000, 0x0001, 0x0002, + /* sah */ + 0x0004, + /* sam */ + 0x0008, + /* sat */ + 0x001c, + /* sc */ + 0x0000, + /* sco */ + 0x0000, 0x0001, 0x0002, + /* sd */ + 0x0006, + /* se */ + 0x0000, 0x0001, + /* sg */ + 0x0000, + /* sgs */ + 0x0000, 0x0001, 0x0003, + /* sh */ + 0x0000, 0x0001, 0x0004, + /* shs */ + 0x0000, 0x0003, + /* si */ + 0x000d, + /* sid */ + 0x0012, 0x0013, + /* sk */ + 0x0000, 0x0001, + /* sm */ + 0x0000, 0x0002, + /* sma */ + 0x0000, + /* smj */ + 0x0000, + /* smn */ + 0x0000, 0x0001, + /* sms */ + 0x0000, 0x0001, 0x0002, + /* so */ + 0x0104, + /* sog */ + 0x010f, + /* sq */ + 0x0000, + /* sr */ + 0x0004, + /* su */ + 0x001b, 0x001c, + /* suz */ + 0x011b, + /* sv */ + 0x0000, + /* syr */ + 0x0007, + /* szl */ + 0x0000, 0x0001, + /* ta */ + 0x000b, + /* tbw */ + 0x0017, + /* tdd */ + 0x0019, + /* te */ + 0x000c, + /* tg */ + 0x0004, + /* th */ + 0x000e, + /* tig */ + 0x0012, 0x0013, + /* tk */ + 0x0000, 0x0001, + /* tl */ + 0x0017, + /* tr */ + 0x0000, 0x0001, + /* tt */ + 0x0004, + /* txg */ + 0x0170, 0x0171, 0x0172, 0x0173, 0x0174, 0x0175, 0x0176, 0x0177, + 0x0178, 0x0179, 0x017a, 0x017b, 0x017c, 0x017d, 0x017e, 0x017f, + 0x0180, 0x0181, 0x0182, 0x0183, 0x0184, 0x0185, 0x0186, 0x0187, + 0x0188, 0x0189, 0x018a, 0x018d, + /* ty */ + 0x0000, 0x0001, 0x0002, + /* ug */ + 0x0006, + /* uga */ + 0x0103, + /* uk */ + 0x0004, + /* und_zmth */ + 0x0000, 0x0001, 0x0003, 0x0020, 0x0021, 0x0022, 0x0023, 0x0025, + 0x0027, 0x01d4, 0x01d5, 0x01d6, + /* und_zsye */ + 0x0023, 0x0025, 0x0026, 0x0027, 0x002b, 0x01f0, 0x01f1, 0x01f2, + 0x01f3, 0x01f4, 0x01f5, 0x01f6, + /* vai */ + 0x00a5, 0x00a6, + /* ve */ + 0x0000, 0x001e, + /* vi */ + 0x0000, 0x0001, 0x0003, 0x001e, + /* vo */ + 0x0000, + /* vot */ + 0x0000, 0x0001, + /* wa */ + 0x0000, + /* wen */ + 0x0000, 0x0001, + /* wo */ + 0x0000, 0x0001, + /* xag */ + 0x0105, + /* xco */ + 0x010f, + /* xcr */ + 0x0102, + /* xlc */ + 0x0102, + /* xld */ + 0x0109, + /* xmr */ + 0x0109, + /* xna */ + 0x010a, + /* xpr */ + 0x010b, + /* xsa */ + 0x010a, + /* xzh */ + 0x011c, + /* yap */ + 0x0000, + /* yo */ + 0x0000, 0x0001, 0x0003, 0x001e, + /* yue */ + 0x0030, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, + 0x003b, 0x003c, 0x003d, 0x003e, 0x003f, 0x0040, 0x0041, 0x0042, + 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, + 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, 0x0050, 0x0051, 0x0052, + 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, + 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 0x0060, 0x0061, 0x0062, + 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, + 0x006b, 0x006c, 0x006d, 0x006e, 0x006f, 0x0070, 0x0071, 0x0072, + 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, + 0x007b, 0x007c, 0x007d, 0x007e, 0x007f, 0x0080, 0x0081, 0x0082, + 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, + 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 0x0090, 0x0091, 0x0092, + 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, + 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 0x0200, 0x0201, 0x0203, + 0x0207, 0x020c, 0x020d, 0x020e, 0x020f, 0x0210, 0x0211, 0x0219, + 0x021a, 0x021c, 0x021d, 0x0220, 0x0221, 0x022a, 0x022b, 0x022c, + 0x022d, 0x022f, 0x0232, 0x0235, 0x0236, 0x023c, 0x023e, 0x023f, + 0x0244, 0x024d, 0x024e, 0x0251, 0x0255, 0x025e, 0x0262, 0x0266, + 0x0267, 0x0268, 0x0269, 0x0272, 0x0275, 0x0276, 0x0277, 0x0278, + 0x0279, 0x027a, 0x027d, 0x0280, 0x0281, 0x0282, 0x0283, 0x0289, + 0x028a, 0x028b, 0x028c, 0x028d, 0x028e, 0x0294, 0x0297, 0x0298, + 0x029a, 0x029d, 0x02a6, + /* zh_cn */ + 0x0002, 0x004e, 0x004f, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, + 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, + 0x005d, 0x005e, 0x005f, 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, + 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, + 0x006d, 0x006e, 0x006f, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, + 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, + 0x007d, 0x007e, 0x007f, 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, + 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, + 0x008d, 0x008e, 0x008f, 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, + 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, + 0x009e, 0x009f, + /* zkt */ + 0x018b, 0x018c, +}, +{ + 0, /* aa */ + 1, /* ab */ + 284, /* ae */ + 2, /* af */ + 252, /* agr */ + 285, /* aho */ + 190, /* ak */ + 333, /* akk */ + 3, /* am */ + 191, /* an */ + 246, /* anp */ + 4, /* ar */ + 286, /* arc */ + 5, /* as */ + 6, /* ast */ + 7, /* av */ + 8, /* ay */ + 253, /* ayc */ + 9, /* az_az */ + 10, /* az_ir */ + 11, /* ba */ + 282, /* ban */ + 283, /* bax */ + 13, /* be */ + 254, /* bem */ + 192, /* ber_dz */ + 193, /* ber_ma */ + 14, /* bg */ + 15, /* bh */ + 247, /* bhb */ + 16, /* bho */ + 17, /* bi */ + 18, /* bin */ + 287, /* bku */ + 288, /* blt */ + 12, /* bm */ + 19, /* bn */ + 20, /* bo */ + 21, /* br */ + 240, /* brx */ + 22, /* bs */ + 23, /* bua */ + 194, /* byn */ + 24, /* ca */ + 289, /* ccp */ + 25, /* ce */ + 26, /* ch */ + 27, /* chm */ + 28, /* chr */ + 290, /* cjm */ + 255, /* ckb */ + 256, /* cmn */ + 29, /* co */ + 280, /* cop */ + 195, /* crh */ + 30, /* cs */ + 196, /* csb */ + 31, /* cu */ + 32, /* cv */ + 33, /* cy */ + 34, /* da */ + 35, /* de */ + 291, /* dmf */ + 242, /* doi */ + 257, /* dsb */ + 197, /* dv */ + 36, /* dz */ + 338, /* ecy */ + 198, /* ee */ + 292, /* egy */ + 293, /* eky */ + 37, /* el */ + 38, /* en */ + 39, /* eo */ + 40, /* es */ + 41, /* et */ + 328, /* ett */ + 42, /* eu */ + 43, /* fa */ + 199, /* fat */ + 48, /* ff */ + 44, /* fi */ + 200, /* fil */ + 45, /* fj */ + 46, /* fo */ + 47, /* fr */ + 49, /* fur */ + 50, /* fy */ + 51, /* ga */ + 52, /* gd */ + 53, /* gez */ + 54, /* gl */ + 294, /* gmy */ + 55, /* gn */ + 279, /* got */ + 56, /* gu */ + 57, /* gv */ + 58, /* ha */ + 258, /* hak */ + 59, /* haw */ + 60, /* he */ + 61, /* hi */ + 248, /* hif */ + 335, /* hit */ + 337, /* hlu */ + 295, /* hmd */ + 201, /* hne */ + 296, /* hnn */ + 62, /* ho */ + 297, /* hoc */ + 63, /* hr */ + 202, /* hsb */ + 203, /* ht */ + 64, /* hu */ + 65, /* hy */ + 204, /* hz */ + 66, /* ia */ + 68, /* id */ + 69, /* ie */ + 67, /* ig */ + 205, /* ii */ + 70, /* ik */ + 71, /* io */ + 72, /* is */ + 73, /* it */ + 74, /* iu */ + 75, /* ja */ + 206, /* jv */ + 76, /* ka */ + 77, /* kaa */ + 207, /* kab */ + 329, /* kaw */ + 298, /* khb */ + 78, /* ki */ + 208, /* kj */ + 79, /* kk */ + 80, /* kl */ + 81, /* km */ + 82, /* kn */ + 83, /* ko */ + 84, /* kok */ + 209, /* kr */ + 85, /* ks */ + 86, /* ku_am */ + 210, /* ku_iq */ + 87, /* ku_ir */ + 211, /* ku_tr */ + 88, /* kum */ + 89, /* kv */ + 90, /* kw */ + 212, /* kwm */ + 91, /* ky */ + 92, /* la */ + 238, /* lah */ + 93, /* lb */ + 299, /* lep */ + 94, /* lez */ + 213, /* lg */ + 214, /* li */ + 300, /* lif */ + 259, /* lij */ + 301, /* lis */ + 95, /* ln */ + 96, /* lo */ + 97, /* lt */ + 98, /* lv */ + 260, /* lzh */ + 249, /* mag */ + 215, /* mai */ + 261, /* mfe */ + 99, /* mg */ + 100, /* mh */ + 262, /* mhr */ + 101, /* mi */ + 302, /* mid */ + 263, /* miq */ + 264, /* mjw */ + 102, /* mk */ + 103, /* ml */ + 104, /* mn_cn */ + 216, /* mn_mn */ + 243, /* mni */ + 265, /* mnw */ + 105, /* mo */ + 106, /* mr */ + 303, /* mro */ + 217, /* ms */ + 107, /* mt */ + 108, /* my */ + 218, /* na */ + 266, /* nan */ + 109, /* nb */ + 110, /* nds */ + 111, /* ne */ + 219, /* ng */ + 267, /* nhn */ + 268, /* niu */ + 112, /* nl */ + 113, /* nn */ + 304, /* nnp */ + 114, /* no */ + 239, /* nqo */ + 115, /* nr */ + 116, /* nso */ + 220, /* nv */ + 117, /* ny */ + 118, /* oc */ + 119, /* om */ + 120, /* or */ + 121, /* os */ + 305, /* osa */ + 221, /* ota */ + 306, /* otk */ + 307, /* oui */ + 122, /* pa */ + 222, /* pa_pk */ + 308, /* pal */ + 223, /* pap_an */ + 224, /* pap_aw */ + 309, /* peo */ + 330, /* pgd */ + 331, /* pgl */ + 310, /* phn */ + 123, /* pl */ + 124, /* ps_af */ + 125, /* ps_pk */ + 126, /* pt */ + 225, /* qu */ + 226, /* quz */ + 250, /* raj */ + 311, /* rhg */ + 269, /* rif */ + 127, /* rm */ + 227, /* rn */ + 128, /* ro */ + 129, /* ru */ + 228, /* rw */ + 130, /* sa */ + 131, /* sah */ + 312, /* sam */ + 241, /* sat */ + 229, /* sc */ + 132, /* sco */ + 230, /* sd */ + 133, /* se */ + 134, /* sel */ + 231, /* sg */ + 270, /* sgs */ + 135, /* sh */ + 271, /* shn */ + 136, /* shs */ + 137, /* si */ + 232, /* sid */ + 138, /* sk */ + 139, /* sl */ + 140, /* sm */ + 141, /* sma */ + 142, /* smj */ + 143, /* smn */ + 144, /* sms */ + 233, /* sn */ + 145, /* so */ + 313, /* sog */ + 146, /* sq */ + 147, /* sr */ + 148, /* ss */ + 149, /* st */ + 234, /* su */ + 334, /* sux */ + 281, /* suz */ + 150, /* sv */ + 151, /* sw */ + 152, /* syr */ + 272, /* szl */ + 153, /* ta */ + 314, /* tbw */ + 273, /* tcy */ + 315, /* tdd */ + 154, /* te */ + 155, /* tg */ + 156, /* th */ + 251, /* the */ + 157, /* ti_er */ + 158, /* ti_et */ + 159, /* tig */ + 160, /* tk */ + 161, /* tl */ + 162, /* tn */ + 163, /* to */ + 274, /* tpi */ + 164, /* tr */ + 165, /* ts */ + 166, /* tt */ + 167, /* tw */ + 316, /* txg */ + 235, /* ty */ + 168, /* tyv */ + 169, /* ug */ + 317, /* uga */ + 170, /* uk */ + 245, /* und_zmth */ + 244, /* und_zsye */ + 275, /* unm */ + 171, /* ur */ + 172, /* uz */ + 318, /* vai */ + 173, /* ve */ + 174, /* vi */ + 175, /* vo */ + 176, /* vot */ + 177, /* wa */ + 276, /* wae */ + 236, /* wal */ + 178, /* wen */ + 179, /* wo */ + 319, /* xag */ + 320, /* xco */ + 321, /* xcr */ + 180, /* xh */ + 322, /* xlc */ + 323, /* xld */ + 324, /* xmr */ + 336, /* xna */ + 325, /* xpr */ + 326, /* xsa */ + 332, /* xzh */ + 181, /* yap */ + 182, /* yi */ + 183, /* yo */ + 277, /* yue */ + 278, /* yuw */ + 237, /* za */ + 184, /* zh_cn */ + 185, /* zh_hk */ + 186, /* zh_mo */ + 187, /* zh_sg */ + 188, /* zh_tw */ + 327, /* zkt */ + 189, /* zu */ +}, +{ + 0, /* aa */ + 1, /* ab */ + 3, /* af */ + 8, /* am */ + 11, /* ar */ + 13, /* as */ + 14, /* ast */ + 15, /* av */ + 16, /* ay */ + 18, /* az_az */ + 19, /* az_ir */ + 20, /* ba */ + 35, /* bm */ + 23, /* be */ + 27, /* bg */ + 28, /* bh */ + 30, /* bho */ + 31, /* bi */ + 32, /* bin */ + 36, /* bn */ + 37, /* bo */ + 38, /* br */ + 40, /* bs */ + 41, /* bua */ + 43, /* ca */ + 45, /* ce */ + 46, /* ch */ + 47, /* chm */ + 48, /* chr */ + 52, /* co */ + 55, /* cs */ + 57, /* cu */ + 58, /* cv */ + 59, /* cy */ + 60, /* da */ + 61, /* de */ + 66, /* dz */ + 71, /* el */ + 72, /* en */ + 73, /* eo */ + 74, /* es */ + 75, /* et */ + 77, /* eu */ + 78, /* fa */ + 81, /* fi */ + 83, /* fj */ + 84, /* fo */ + 85, /* fr */ + 80, /* ff */ + 86, /* fur */ + 87, /* fy */ + 88, /* ga */ + 89, /* gd */ + 90, /* gez */ + 91, /* gl */ + 93, /* gn */ + 95, /* gu */ + 96, /* gv */ + 97, /* ha */ + 99, /* haw */ + 100, /* he */ + 101, /* hi */ + 108, /* ho */ + 110, /* hr */ + 113, /* hu */ + 114, /* hy */ + 116, /* ia */ + 119, /* ig */ + 117, /* id */ + 118, /* ie */ + 121, /* ik */ + 122, /* io */ + 123, /* is */ + 124, /* it */ + 125, /* iu */ + 126, /* ja */ + 128, /* ka */ + 129, /* kaa */ + 133, /* ki */ + 135, /* kk */ + 136, /* kl */ + 137, /* km */ + 138, /* kn */ + 139, /* ko */ + 140, /* kok */ + 142, /* ks */ + 143, /* ku_am */ + 145, /* ku_ir */ + 147, /* kum */ + 148, /* kv */ + 149, /* kw */ + 151, /* ky */ + 152, /* la */ + 154, /* lb */ + 156, /* lez */ + 162, /* ln */ + 163, /* lo */ + 164, /* lt */ + 165, /* lv */ + 170, /* mg */ + 171, /* mh */ + 173, /* mi */ + 177, /* mk */ + 178, /* ml */ + 179, /* mn_cn */ + 183, /* mo */ + 184, /* mr */ + 187, /* mt */ + 188, /* my */ + 191, /* nb */ + 192, /* nds */ + 193, /* ne */ + 197, /* nl */ + 198, /* nn */ + 200, /* no */ + 202, /* nr */ + 203, /* nso */ + 205, /* ny */ + 206, /* oc */ + 207, /* om */ + 208, /* or */ + 209, /* os */ + 214, /* pa */ + 223, /* pl */ + 224, /* ps_af */ + 225, /* ps_pk */ + 226, /* pt */ + 232, /* rm */ + 234, /* ro */ + 235, /* ru */ + 237, /* sa */ + 238, /* sah */ + 242, /* sco */ + 244, /* se */ + 245, /* sel */ + 248, /* sh */ + 250, /* shs */ + 251, /* si */ + 253, /* sk */ + 254, /* sl */ + 255, /* sm */ + 256, /* sma */ + 257, /* smj */ + 258, /* smn */ + 259, /* sms */ + 261, /* so */ + 263, /* sq */ + 264, /* sr */ + 265, /* ss */ + 266, /* st */ + 270, /* sv */ + 271, /* sw */ + 272, /* syr */ + 274, /* ta */ + 278, /* te */ + 279, /* tg */ + 280, /* th */ + 282, /* ti_er */ + 283, /* ti_et */ + 284, /* tig */ + 285, /* tk */ + 286, /* tl */ + 287, /* tn */ + 288, /* to */ + 290, /* tr */ + 291, /* ts */ + 292, /* tt */ + 293, /* tw */ + 296, /* tyv */ + 297, /* ug */ + 299, /* uk */ + 303, /* ur */ + 304, /* uz */ + 306, /* ve */ + 307, /* vi */ + 308, /* vo */ + 309, /* vot */ + 310, /* wa */ + 313, /* wen */ + 314, /* wo */ + 318, /* xh */ + 326, /* yap */ + 327, /* yi */ + 328, /* yo */ + 332, /* zh_cn */ + 333, /* zh_hk */ + 334, /* zh_mo */ + 335, /* zh_sg */ + 336, /* zh_tw */ + 338, /* zu */ + 6, /* ak */ + 9, /* an */ + 25, /* ber_dz */ + 26, /* ber_ma */ + 42, /* byn */ + 54, /* crh */ + 56, /* csb */ + 65, /* dv */ + 68, /* ee */ + 79, /* fat */ + 82, /* fil */ + 106, /* hne */ + 111, /* hsb */ + 112, /* ht */ + 115, /* hz */ + 120, /* ii */ + 127, /* jv */ + 130, /* kab */ + 134, /* kj */ + 141, /* kr */ + 144, /* ku_iq */ + 146, /* ku_tr */ + 150, /* kwm */ + 157, /* lg */ + 158, /* li */ + 168, /* mai */ + 180, /* mn_mn */ + 186, /* ms */ + 189, /* na */ + 194, /* ng */ + 204, /* nv */ + 211, /* ota */ + 215, /* pa_pk */ + 217, /* pap_an */ + 218, /* pap_aw */ + 227, /* qu */ + 228, /* quz */ + 233, /* rn */ + 236, /* rw */ + 241, /* sc */ + 243, /* sd */ + 246, /* sg */ + 252, /* sid */ + 260, /* sn */ + 267, /* su */ + 295, /* ty */ + 312, /* wal */ + 331, /* za */ + 153, /* lah */ + 201, /* nqo */ + 39, /* brx */ + 240, /* sat */ + 63, /* doi */ + 181, /* mni */ + 301, /* und_zsye */ + 300, /* und_zmth */ + 10, /* anp */ + 29, /* bhb */ + 102, /* hif */ + 167, /* mag */ + 229, /* raj */ + 281, /* the */ + 4, /* agr */ + 17, /* ayc */ + 24, /* bem */ + 50, /* ckb */ + 51, /* cmn */ + 64, /* dsb */ + 98, /* hak */ + 160, /* lij */ + 166, /* lzh */ + 169, /* mfe */ + 172, /* mhr */ + 175, /* miq */ + 176, /* mjw */ + 182, /* mnw */ + 190, /* nan */ + 195, /* nhn */ + 196, /* niu */ + 231, /* rif */ + 247, /* sgs */ + 249, /* shn */ + 273, /* szl */ + 276, /* tcy */ + 289, /* tpi */ + 302, /* unm */ + 311, /* wae */ + 329, /* yue */ + 330, /* yuw */ + 94, /* got */ + 53, /* cop */ + 269, /* suz */ + 21, /* ban */ + 22, /* bax */ + 2, /* ae */ + 5, /* aho */ + 12, /* arc */ + 33, /* bku */ + 34, /* blt */ + 44, /* ccp */ + 49, /* cjm */ + 62, /* dmf */ + 69, /* egy */ + 70, /* eky */ + 92, /* gmy */ + 105, /* hmd */ + 107, /* hnn */ + 109, /* hoc */ + 132, /* khb */ + 155, /* lep */ + 159, /* lif */ + 161, /* lis */ + 174, /* mid */ + 185, /* mro */ + 199, /* nnp */ + 210, /* osa */ + 212, /* otk */ + 213, /* oui */ + 216, /* pal */ + 219, /* peo */ + 222, /* phn */ + 230, /* rhg */ + 239, /* sam */ + 262, /* sog */ + 275, /* tbw */ + 277, /* tdd */ + 294, /* txg */ + 298, /* uga */ + 305, /* vai */ + 315, /* xag */ + 316, /* xco */ + 317, /* xcr */ + 319, /* xlc */ + 320, /* xld */ + 321, /* xmr */ + 323, /* xpr */ + 324, /* xsa */ + 337, /* zkt */ + 76, /* ett */ + 131, /* kaw */ + 220, /* pgd */ + 221, /* pgl */ + 325, /* xzh */ + 7, /* akk */ + 268, /* sux */ + 103, /* hit */ + 322, /* xna */ + 104, /* hlu */ + 67, /* ecy */ +} +}; + +#define NUM_LANG_CHAR_SET 339 +#define NUM_LANG_SET_MAP 11 + +static const FcChar32 fcLangCountrySets[][NUM_LANG_SET_MAP] = { + { 0x00000600, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, }, /* az */ + { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x00000000, 0x00000000, 0x00000000, }, /* ber */ + { 0x00000000, 0x00000000, 0x00c00000, 0x00000000, 0x00000000, 0x00000000, 0x000c0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, }, /* ku */ + { 0x00000000, 0x00000000, 0x00000000, 0x00000100, 0x00000000, 0x00000000, 0x01000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, }, /* mn */ + { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x40000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, }, /* pa */ + { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x80000000, 0x00000001, 0x00000000, 0x00000000, 0x00000000, }, /* pap */ + { 0x00000000, 0x00000000, 0x00000000, 0x30000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, }, /* ps */ + { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x60000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, }, /* ti */ + { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00300000, 0x00000000, 0x00000000, 0x00000000, }, /* und */ + { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1f000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, }, /* zh */ +}; + +#define NUM_COUNTRY_SET 10 + +static const FcLangCharSetRange fcLangCharSetRanges[] = { + + { 0, 19 }, /* a */ + { 20, 42 }, /* b */ + { 43, 59 }, /* c */ + { 60, 66 }, /* d */ + { 67, 77 }, /* e */ + { 78, 87 }, /* f */ + { 88, 96 }, /* g */ + { 97, 115 }, /* h */ + { 116, 125 }, /* i */ + { 126, 127 }, /* j */ + { 128, 151 }, /* k */ + { 152, 166 }, /* l */ + { 167, 188 }, /* m */ + { 189, 205 }, /* n */ + { 206, 213 }, /* o */ + { 214, 226 }, /* p */ + { 227, 228 }, /* q */ + { 229, 236 }, /* r */ + { 237, 273 }, /* s */ + { 274, 296 }, /* t */ + { 297, 304 }, /* u */ + { 305, 309 }, /* v */ + { 310, 314 }, /* w */ + { 315, 325 }, /* x */ + { 326, 330 }, /* y */ + { 331, 338 }, /* z */ +}; + diff --git a/pkg/fontconfig/override/fontconfig/fontconfig.h b/pkg/fontconfig/override/fontconfig/fontconfig.h new file mode 100644 index 000000000..3c5cca57a --- /dev/null +++ b/pkg/fontconfig/override/fontconfig/fontconfig.h @@ -0,0 +1,1245 @@ +/* + * fontconfig/fontconfig/fontconfig.h + * + * Copyright © 2001 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the author(s) not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors make no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _FONTCONFIG_H_ +#define _FONTCONFIG_H_ + +#include +#include +#include +#include + +#if defined(__GNUC__) && (__GNUC__ >= 4) +# define FC_ATTRIBUTE_SENTINEL(x) __attribute__ ((__sentinel__ (0))) +# define FC_ATTRIBUTE_MAY_ALIAS __attribute__ ((may_alias)) +#else +# define FC_ATTRIBUTE_SENTINEL(x) +# define FC_ATTRIBUTE_MAY_ALIAS +#endif + +#ifndef FcPublic +# define FcPublic +#endif + +typedef unsigned char FcChar8; +typedef unsigned short FcChar16; +typedef unsigned int FcChar32; +typedef int FcBool; + +/* + * Current Fontconfig version number. This same number + * must appear in the fontconfig configure.in file. Yes, + * it'a a pain to synchronize version numbers like this. + */ + +#define FC_MAJOR 2 +#define FC_MINOR 18 +#define FC_REVISION 3 + +#define FC_VERSION ((FC_MAJOR * 10000) + (FC_MINOR * 100) + (FC_REVISION)) + +/* + * Current font cache file format version + * This is appended to the cache files so that multiple + * versions of the library will peacefully coexist + * + * Change this value whenever the disk format for the cache file + * changes in any non-compatible way. Try to avoid such changes as + * it means multiple copies of the font information. + */ + +#define FC_CACHE_VERSION_NUMBER 12 +#define FC_CACHE_SNAP_VERSION_NUMBER 0 +#define FC_NEXT_CACHE_VERSION_NUMBER 0 +#define FC_CACHE_MIN_COMPAT_VERSION 9 + +#define _FC_STRINGIFY_(s) #s +#define _FC_STRINGIFY(s) _FC_STRINGIFY_ (s) +#if FC_NEXT_CACHE_VERSION_NUMBER > 0 +# define FC_CACHE_VERSION _FC_STRINGIFY (FC_NEXT_CACHE_VERSION_NUMBER) "~snap" _FC_STRINGIFY (FC_CACHE_SNAP_VERSION_NUMBER) +#else +# define FC_CACHE_VERSION _FC_STRINGIFY (FC_CACHE_VERSION_NUMBER) +#endif + +#define FcFalse 0 +#define FcTrue 1 +#define FcDontCare 2 + +#define FC_FAMILY "family" /* String */ +#define FC_STYLE "style" /* String */ +#define FC_SLANT "slant" /* Int */ +#define FC_WEIGHT "weight" /* Int */ +#define FC_SIZE "size" /* Range (double) */ +#define FC_ASPECT "aspect" /* Double */ +#define FC_PIXEL_SIZE "pixelsize" /* Double */ +#define FC_SPACING "spacing" /* Int */ +#define FC_FOUNDRY "foundry" /* String */ +#define FC_ANTIALIAS "antialias" /* Bool (depends) */ +#define FC_HINTING "hinting" /* Bool (true) */ +#define FC_HINT_STYLE "hintstyle" /* Int */ +#define FC_VERTICAL_LAYOUT "verticallayout" /* Bool (false) */ +#define FC_AUTOHINT "autohint" /* Bool (false) */ +/* FC_GLOBAL_ADVANCE is deprecated. this is simply ignored on freetype 2.4.5 or later */ +#define FC_GLOBAL_ADVANCE "globaladvance" /* Bool (true) */ +#define FC_WIDTH "width" /* Int */ +#define FC_FILE "file" /* String */ +#define FC_INDEX "index" /* Int */ +#define FC_FT_FACE "ftface" /* FT_Face */ +#define FC_RASTERIZER "rasterizer" /* String (deprecated) */ +#define FC_OUTLINE "outline" /* Bool */ +#define FC_SCALABLE "scalable" /* Bool */ +#define FC_COLOR "color" /* Bool */ +#define FC_VARIABLE "variable" /* Bool */ +#define FC_SCALE "scale" /* double (deprecated) */ +#define FC_SYMBOL "symbol" /* Bool */ +#define FC_DPI "dpi" /* double */ +#define FC_RGBA "rgba" /* Int */ +#define FC_MINSPACE "minspace" /* Bool use minimum line spacing */ +#define FC_SOURCE "source" /* String (deprecated) */ +#define FC_CHARSET "charset" /* CharSet */ +#define FC_LANG "lang" /* LangSet Set of RFC 3066 langs */ +#define FC_FONTVERSION "fontversion" /* Int from 'head' table */ +#define FC_FULLNAME "fullname" /* String */ +#define FC_FAMILYLANG "familylang" /* String RFC 3066 langs */ +#define FC_STYLELANG "stylelang" /* String RFC 3066 langs */ +#define FC_FULLNAMELANG "fullnamelang" /* String RFC 3066 langs */ +#define FC_CAPABILITY "capability" /* String */ +#define FC_FONTFORMAT "fontformat" /* String */ +#define FC_EMBOLDEN "embolden" /* Bool - true if emboldening needed*/ +#define FC_EMBEDDED_BITMAP "embeddedbitmap" /* Bool - true to enable embedded bitmaps */ +#define FC_DECORATIVE "decorative" /* Bool - true if style is a decorative variant */ +#define FC_LCD_FILTER "lcdfilter" /* Int */ +#define FC_FONT_FEATURES "fontfeatures" /* String */ +#define FC_FONT_VARIATIONS "fontvariations" /* String */ +#define FC_NAMELANG "namelang" /* String RFC 3866 langs */ +#define FC_PRGNAME "prgname" /* String */ +#define FC_HASH "hash" /* String (deprecated) */ +#define FC_POSTSCRIPT_NAME "postscriptname" /* String */ +#define FC_FONT_HAS_HINT "fonthashint" /* Bool - true if font has hinting */ +#define FC_ORDER "order" /* Integer */ +#define FC_DESKTOP_NAME "desktop" /* String */ +#define FC_NAMED_INSTANCE "namedinstance" /* Bool - true if font is named instance */ +#define FC_FONT_WRAPPER "fontwrapper" /* String */ +#define FC_GENERIC_FAMILY "genericfamily" /* Integer */ + +#define FC_CACHE_SUFFIX ".cache-" FC_CACHE_VERSION +#define FC_DIR_CACHE_FILE "fonts.cache-" FC_CACHE_VERSION +#define FC_USER_CACHE_FILE ".fonts.cache-" FC_CACHE_VERSION + +/* Adjust outline rasterizer */ +#define FC_CHARWIDTH "charwidth" /* Int */ +#define FC_CHAR_WIDTH FC_CHARWIDTH +#define FC_CHAR_HEIGHT "charheight" /* Int */ +#define FC_MATRIX "matrix" /* FcMatrix */ + +#define FC_WEIGHT_THIN 0 +#define FC_WEIGHT_EXTRALIGHT 40 +#define FC_WEIGHT_ULTRALIGHT FC_WEIGHT_EXTRALIGHT +#define FC_WEIGHT_LIGHT 50 +#define FC_WEIGHT_DEMILIGHT 55 +#define FC_WEIGHT_SEMILIGHT FC_WEIGHT_DEMILIGHT +#define FC_WEIGHT_BOOK 75 +#define FC_WEIGHT_REGULAR 80 +#define FC_WEIGHT_NORMAL FC_WEIGHT_REGULAR +#define FC_WEIGHT_MEDIUM 100 +#define FC_WEIGHT_DEMIBOLD 180 +#define FC_WEIGHT_SEMIBOLD FC_WEIGHT_DEMIBOLD +#define FC_WEIGHT_BOLD 200 +#define FC_WEIGHT_EXTRABOLD 205 +#define FC_WEIGHT_ULTRABOLD FC_WEIGHT_EXTRABOLD +#define FC_WEIGHT_BLACK 210 +#define FC_WEIGHT_HEAVY FC_WEIGHT_BLACK +#define FC_WEIGHT_EXTRABLACK 215 +#define FC_WEIGHT_ULTRABLACK FC_WEIGHT_EXTRABLACK + +#define FC_SLANT_ROMAN 0 +#define FC_SLANT_ITALIC 100 +#define FC_SLANT_OBLIQUE 110 + +#define FC_WIDTH_ULTRACONDENSED 50 +#define FC_WIDTH_EXTRACONDENSED 63 +#define FC_WIDTH_CONDENSED 75 +#define FC_WIDTH_SEMICONDENSED 87 +#define FC_WIDTH_NORMAL 100 +#define FC_WIDTH_SEMIEXPANDED 113 +#define FC_WIDTH_EXPANDED 125 +#define FC_WIDTH_EXTRAEXPANDED 150 +#define FC_WIDTH_ULTRAEXPANDED 200 + +#define FC_SPACING_PROPORTIONAL 0 +#define FC_SPACING_DUAL 90 +#define FC_SPACING_MONO 100 +#define FC_SPACING_CHARCELL 110 +#define FC_PROPORTIONAL FC_SPACING_PROPORTIONAL +#define FC_DUAL FC_SPACING_DUAL +#define FC_MONO FC_SPACING_MONO +#define FC_CHARCELL FC_SPACING_CHARCELL + +/* sub-pixel order */ +#define FC_RGBA_UNKNOWN 0 +#define FC_RGBA_RGB 1 +#define FC_RGBA_BGR 2 +#define FC_RGBA_VRGB 3 +#define FC_RGBA_VBGR 4 +#define FC_RGBA_NONE 5 + +/* hinting style */ +#define FC_HINT_NONE 0 +#define FC_HINT_SLIGHT 1 +#define FC_HINT_MEDIUM 2 +#define FC_HINT_FULL 3 + +/* LCD filter */ +#define FC_LCD_NONE 0 +#define FC_LCD_DEFAULT 1 +#define FC_LCD_LIGHT 2 +#define FC_LCD_LEGACY 3 + +/* Generic family */ +#define FC_FAMILY_UNKNOWN 0 +#define FC_FAMILY_SERIF 1 +#define FC_FAMILY_SANS 2 +#define FC_FAMILY_MONO 3 +#define FC_FAMILY_CURSIVE 4 +#define FC_FAMILY_FANTASY 5 +#define FC_FAMILY_SYSTEM_UI 6 +#define FC_FAMILY_UI_SERIF 7 +#define FC_FAMILY_UI_SANS 8 +#define FC_FAMILY_UI_MONO 9 +#define FC_FAMILY_UI_ROUNDED 10 +#define FC_FAMILY_EMOJI 11 +#define FC_FAMILY_MATH 12 +#define FC_FAMILY_FANGSONG 13 + +/* Warnings */ +#define FC_WARN_INVALID_ATTR (1 << 0) + +typedef enum _FcType { + FcTypeUnknown = -1, + FcTypeVoid, + FcTypeInteger, + FcTypeDouble, + FcTypeString, + FcTypeBool, + FcTypeMatrix, + FcTypeCharSet, + FcTypeFTFace, + FcTypeLangSet, + FcTypeRange +} FcType; + +typedef int FcObject; + +typedef struct _FcMatrix { + double xx, xy, yx, yy; +} FcMatrix; + +#define FcMatrixInit(m) ((m)->xx = (m)->yy = 1, \ + (m)->xy = (m)->yx = 0) + +/* + * A data structure to represent the available glyphs in a font. + * This is represented as a sparse boolean btree. + */ + +typedef struct _FcCharSet FcCharSet; + +typedef struct _FcObjectType { + char *object; + FcType type; +} FcObjectType; + +typedef struct _FcConstant { + const FcChar8 *name; + const char *object; + int value; +} FcConstant; + +typedef enum _FcResult { + FcResultMatch, + FcResultNoMatch, + FcResultTypeMismatch, + FcResultNoId, + FcResultOutOfMemory +} FcResult; + +typedef enum _FcValueBinding { + FcValueBindingWeak, + FcValueBindingStrong, + FcValueBindingSame, + /* to make sure sizeof (FcValueBinding) == 4 even with -fshort-enums */ + FcValueBindingEnd = INT_MAX +} FcValueBinding; + +typedef struct _FcPattern FcPattern; + +typedef struct FC_ATTRIBUTE_MAY_ALIAS _FcPatternIter { + void *dummy1; + void *dummy2; +} FcPatternIter; + +typedef struct _FcLangSet FcLangSet; + +typedef struct _FcRange FcRange; + +typedef struct _FcValue { + FcType type; + union { + const FcChar8 *s; + int i; + FcBool b; + double d; + const FcMatrix *m; + const FcCharSet *c; + void *f; + const FcLangSet *l; + const FcRange *r; + } u; +} FcValue; + +typedef struct _FcFontSet { + int nfont; + int sfont; + FcPattern **fonts; +} FcFontSet; + +typedef struct _FcObjectSet { + int nobject; /* deprecated */ + int sobject; + const char **objects; /* deprecated */ + int nobjIds; + FcObject *objIds; +} FcObjectSet; + +typedef enum _FcMatchKind { + FcMatchPattern, + FcMatchFont, + FcMatchScan, + FcMatchKindEnd, + FcMatchKindBegin = FcMatchPattern +} FcMatchKind; + +typedef enum _FcLangResult { + FcLangEqual = 0, + FcLangDifferentCountry = 1, + FcLangDifferentTerritory = 1, + FcLangDifferentLang = 2 +} FcLangResult; + +typedef enum _FcSetName { + FcSetSystem = 0, + FcSetApplication = 1 +} FcSetName; + +typedef struct _FcConfigFileInfoIter { + void *dummy1; + void *dummy2; + void *dummy3; +} FcConfigFileInfoIter; + +typedef struct _FcAtomic FcAtomic; + +#if defined(__cplusplus) || defined(c_plusplus) /* for C++ V2.0 */ +# define _FCFUNCPROTOBEGIN extern "C" { /* do not leave open across includes */ +# define _FCFUNCPROTOEND } +#else +# define _FCFUNCPROTOBEGIN +# define _FCFUNCPROTOEND +#endif + +typedef enum { FcEndianBig, + FcEndianLittle } FcEndian; + +typedef struct _FcConfig FcConfig; + +typedef struct _FcGlobalCache FcFileCache; + +typedef struct _FcBlanks FcBlanks; + +typedef struct _FcStrList FcStrList; + +typedef struct _FcStrSet FcStrSet; + +typedef struct _FcCache FcCache; + +typedef void (*FcDestroyFunc) (void *data); +typedef FcBool (*FcFilterFontSetFunc) (const FcPattern *font, void *user_data); + +_FCFUNCPROTOBEGIN + +/* fcblanks.c */ +FcPublic FcBlanks * +FcBlanksCreate (void); + +FcPublic void +FcBlanksDestroy (FcBlanks *b); + +FcPublic FcBool +FcBlanksAdd (FcBlanks *b, FcChar32 ucs4); + +FcPublic FcBool +FcBlanksIsMember (FcBlanks *b, FcChar32 ucs4); + +/* fccache.c */ + +FcPublic const FcChar8 * +FcCacheDir (const FcCache *c); + +FcPublic FcFontSet * +FcCacheCopySet (const FcCache *c); + +FcPublic const FcChar8 * +FcCacheSubdir (const FcCache *c, int i); + +FcPublic int +FcCacheNumSubdir (const FcCache *c); + +FcPublic int +FcCacheNumFont (const FcCache *c); + +FcPublic FcBool +FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config); + +FcPublic FcBool +FcDirCacheValid (const FcChar8 *cache_file); + +FcPublic FcBool +FcDirCacheClean (const FcChar8 *cache_dir, FcBool verbose); + +FcPublic void +FcCacheCreateTagFile (FcConfig *config); + +FcPublic FcBool +FcDirCacheCreateUUID (FcChar8 *dir, + FcBool force, + FcConfig *config); + +FcPublic FcBool +FcDirCacheDeleteUUID (const FcChar8 *dir, + FcConfig *config); + +/* fccfg.c */ +FcPublic FcChar8 * +FcConfigHome (void); + +FcPublic FcBool +FcConfigEnableHome (FcBool enable); + +FcPublic FcChar8 * +FcConfigGetFilename (FcConfig *config, + const FcChar8 *url); + +FcPublic FcChar8 * +FcConfigFilename (const FcChar8 *url); + +FcPublic FcConfig * +FcConfigCreate (void); + +FcPublic FcConfig * +FcConfigReference (FcConfig *config); + +FcPublic void +FcConfigDestroy (FcConfig *config); + +FcPublic FcBool +FcConfigSetCurrent (FcConfig *config); + +FcPublic FcConfig * +FcConfigGetCurrent (void); + +FcPublic FcBool +FcConfigUptoDate (FcConfig *config); + +FcPublic FcBool +FcConfigBuildFonts (FcConfig *config); + +FcPublic FcStrList * +FcConfigGetFontDirs (FcConfig *config); + +FcPublic FcStrList * +FcConfigGetConfigDirs (FcConfig *config); + +FcPublic FcStrList * +FcConfigGetConfigFiles (FcConfig *config); + +FcPublic FcChar8 * +FcConfigGetCache (FcConfig *config); + +FcPublic FcBlanks * +FcConfigGetBlanks (FcConfig *config); + +FcPublic FcStrList * +FcConfigGetCacheDirs (FcConfig *config); + +FcPublic int +FcConfigGetRescanInterval (FcConfig *config); + +FcPublic FcBool +FcConfigSetRescanInterval (FcConfig *config, int rescanInterval); + +FcPublic FcFontSet * +FcConfigGetFonts (FcConfig *config, + FcSetName set); + +FcPublic FcBool +FcConfigAcceptFont (FcConfig *config, + const FcPattern *font); + +FcPublic FcBool +FcConfigAcceptFilename (FcConfig *config, + const FcChar8 *filename); + +FcPublic FcBool +FcConfigAcceptFilter (FcConfig *config, + const FcPattern *font); + +FcPublic FcBool +FcConfigAppFontAddFile (FcConfig *config, + const FcChar8 *file); + +FcPublic FcBool +FcConfigAppFontAddDir (FcConfig *config, + const FcChar8 *dir); + +FcPublic void +FcConfigAppFontClear (FcConfig *config); + +FcPublic void +FcConfigPreferAppFont (FcConfig *config, FcBool flag); + +FcPublic void +FcConfigSetWarningFlags (FcConfig *config, int warn, FcBool flag); + +FcPublic int +FcConfigGetWarningFlags (FcConfig *config); + +FcPublic FcBool +FcConfigSubstituteWithPat (FcConfig *config, + FcPattern *p, + FcPattern *p_pat, + FcMatchKind kind); + +FcPublic FcBool +FcConfigSubstitute (FcConfig *config, + FcPattern *p, + FcMatchKind kind); + +FcPublic const FcChar8 * +FcConfigGetSysRoot (const FcConfig *config); + +FcPublic void +FcConfigSetSysRoot (FcConfig *config, + const FcChar8 *sysroot); + +FcPublic FcConfig * +FcConfigSetFontSetFilter (FcConfig *config, + FcFilterFontSetFunc filter_func, + FcDestroyFunc destroy_data_func, + void *user_data); + +FcPublic void +FcConfigFileInfoIterInit (FcConfig *config, + FcConfigFileInfoIter *iter); + +FcPublic FcBool +FcConfigFileInfoIterNext (FcConfig *config, + FcConfigFileInfoIter *iter); + +FcPublic FcBool +FcConfigFileInfoIterGet (FcConfig *config, + FcConfigFileInfoIter *iter, + FcChar8 **name, + FcChar8 **description, + FcBool *enabled); + +/* fccharset.c */ +FcPublic FcCharSet * +FcCharSetCreate (void); + +/* deprecated alias for FcCharSetCreate */ +FcPublic FcCharSet * +FcCharSetNew (void); + +FcPublic void +FcCharSetDestroy (FcCharSet *fcs); + +FcPublic FcBool +FcCharSetAddChar (FcCharSet *fcs, FcChar32 ucs4); + +FcPublic FcBool +FcCharSetDelChar (FcCharSet *fcs, FcChar32 ucs4); + +FcPublic FcCharSet * +FcCharSetCopy (FcCharSet *src); + +FcPublic FcBool +FcCharSetEqual (const FcCharSet *a, const FcCharSet *b); + +FcPublic FcCharSet * +FcCharSetIntersect (const FcCharSet *a, const FcCharSet *b); + +FcPublic FcCharSet * +FcCharSetUnion (const FcCharSet *a, const FcCharSet *b); + +FcPublic FcCharSet * +FcCharSetSubtract (const FcCharSet *a, const FcCharSet *b); + +FcPublic FcBool +FcCharSetMerge (FcCharSet *a, const FcCharSet *b, FcBool *changed); + +FcPublic FcBool +FcCharSetHasChar (const FcCharSet *fcs, FcChar32 ucs4); + +FcPublic FcChar32 +FcCharSetCount (const FcCharSet *a); + +FcPublic FcChar32 +FcCharSetIntersectCount (const FcCharSet *a, const FcCharSet *b); + +FcPublic FcChar32 +FcCharSetSubtractCount (const FcCharSet *a, const FcCharSet *b); + +FcPublic FcBool +FcCharSetIsSubset (const FcCharSet *a, const FcCharSet *b); + +#define FC_CHARSET_MAP_SIZE (256 / 32) +#define FC_CHARSET_DONE ((FcChar32) - 1) + +FcPublic FcChar32 +FcCharSetFirstPage (const FcCharSet *a, + FcChar32 map[FC_CHARSET_MAP_SIZE], + FcChar32 *next); + +FcPublic FcChar32 +FcCharSetNextPage (const FcCharSet *a, + FcChar32 map[FC_CHARSET_MAP_SIZE], + FcChar32 *next); + +/* + * old coverage API, rather hard to use correctly + */ + +FcPublic FcChar32 +FcCharSetCoverage (const FcCharSet *a, FcChar32 page, FcChar32 *result); + +/* fcdbg.c */ +FcPublic void +FcValuePrint (const FcValue v); + +FcPublic void +FcPatternPrint (const FcPattern *p); + +FcPublic void +FcFontSetPrint (const FcFontSet *s); + +/* fcdefault.c */ +FcPublic FcStrSet * +FcConfigGetDefaultLangs (FcConfig *config); + +FcPublic FcStrSet * +FcGetDefaultLangs (void); + +FcPublic void +FcConfigSetDefaultSubstitute (FcConfig *config, + FcPattern *pattern); + +FcPublic void +FcDefaultSubstitute (FcPattern *pattern); + +/* fcdir.c */ +FcPublic FcBool +FcFileIsDir (const FcChar8 *file); + +FcPublic FcBool +FcFileScan (FcFontSet *set, + FcStrSet *dirs, + FcFileCache *cache, + FcBlanks *blanks, + const FcChar8 *file, + FcBool force); + +FcPublic FcBool +FcDirScan (FcFontSet *set, + FcStrSet *dirs, + FcFileCache *cache, + FcBlanks *blanks, + const FcChar8 *dir, + FcBool force); + +FcPublic FcBool +FcDirSave (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir); + +FcPublic FcCache * +FcDirCacheLoad (const FcChar8 *dir, FcConfig *config, FcChar8 **cache_file); + +FcPublic FcCache * +FcDirCacheRescan (const FcChar8 *dir, FcConfig *config); + +FcPublic FcCache * +FcDirCacheRead (const FcChar8 *dir, FcBool force, FcConfig *config); + +FcPublic FcCache * +FcDirCacheLoadFile (const FcChar8 *cache_file, struct stat *file_stat); + +FcPublic void +FcDirCacheUnload (FcCache *cache); + +/* fcfs.c */ + +FcPublic FcFontSet * +FcFontSetCreate (void); + +FcPublic void +FcFontSetDestroy (FcFontSet *s); + +FcPublic FcBool +FcFontSetAdd (FcFontSet *s, FcPattern *font); + +/* fcinit.c */ +FcPublic FcConfig * +FcInitLoadConfig (void); + +FcPublic FcConfig * +FcInitLoadConfigAndFonts (void); + +FcPublic FcBool +FcInit (void); + +FcPublic void +FcFini (void); + +FcPublic int +FcGetVersion (void); + +FcPublic FcBool +FcInitReinitialize (void); + +FcPublic FcBool +FcInitBringUptoDate (void); + +/* fclang.c */ +FcPublic FcStrSet * +FcGetLangs (void); + +FcPublic FcChar8 * +FcLangNormalize (const FcChar8 *lang); + +FcPublic const FcCharSet * +FcLangGetCharSet (const FcChar8 *lang); + +FcPublic FcLangSet * +FcLangSetCreate (void); + +FcPublic void +FcLangSetDestroy (FcLangSet *ls); + +FcPublic FcLangSet * +FcLangSetCopy (const FcLangSet *ls); + +FcPublic FcBool +FcLangSetAdd (FcLangSet *ls, const FcChar8 *lang); + +FcPublic FcBool +FcLangSetDel (FcLangSet *ls, const FcChar8 *lang); + +FcPublic FcLangResult +FcLangSetHasLang (const FcLangSet *ls, const FcChar8 *lang); + +FcPublic FcLangResult +FcLangSetCompare (const FcLangSet *lsa, const FcLangSet *lsb); + +FcPublic FcBool +FcLangSetContains (const FcLangSet *lsa, const FcLangSet *lsb); + +FcPublic FcBool +FcLangSetEqual (const FcLangSet *lsa, const FcLangSet *lsb); + +FcPublic FcChar32 +FcLangSetHash (const FcLangSet *ls); + +FcPublic FcStrSet * +FcLangSetGetLangs (const FcLangSet *ls); + +FcPublic FcLangSet * +FcLangSetUnion (const FcLangSet *a, const FcLangSet *b); + +FcPublic FcLangSet * +FcLangSetSubtract (const FcLangSet *a, const FcLangSet *b); + +/* fclist.c */ +FcPublic FcObjectSet * +FcObjectSetCreate (void); + +FcPublic FcBool +FcObjectSetAdd (FcObjectSet *os, const char *object); + +FcPublic void +FcObjectSetDestroy (FcObjectSet *os); + +FcPublic FcObjectSet * +FcObjectSetVaBuild (const char *first, va_list va); + +FcPublic FcObjectSet * +FcObjectSetBuild (const char *first, ...) FC_ATTRIBUTE_SENTINEL (0); + +FcPublic FcFontSet * +FcFontSetList (FcConfig *config, + FcFontSet **sets, + int nsets, + FcPattern *p, + FcObjectSet *os); + +FcPublic FcFontSet * +FcFontList (FcConfig *config, + FcPattern *p, + FcObjectSet *os); + +/* fcatomic.c */ + +FcPublic FcAtomic * +FcAtomicCreate (const FcChar8 *file); + +FcPublic FcBool +FcAtomicLock (FcAtomic *atomic); + +FcPublic FcChar8 * +FcAtomicNewFile (FcAtomic *atomic); + +FcPublic FcChar8 * +FcAtomicOrigFile (FcAtomic *atomic); + +FcPublic FcBool +FcAtomicReplaceOrig (FcAtomic *atomic); + +FcPublic void +FcAtomicDeleteNew (FcAtomic *atomic); + +FcPublic void +FcAtomicUnlock (FcAtomic *atomic); + +FcPublic void +FcAtomicDestroy (FcAtomic *atomic); + +/* fcmatch.c */ +FcPublic FcPattern * +FcFontSetMatch (FcConfig *config, + FcFontSet **sets, + int nsets, + FcPattern *p, + FcResult *result); + +FcPublic FcPattern * +FcFontMatch (FcConfig *config, + FcPattern *p, + FcResult *result); + +FcPublic FcPattern * +FcFontRenderPrepare (FcConfig *config, + FcPattern *pat, + FcPattern *font); + +FcPublic FcFontSet * +FcFontSetSort (FcConfig *config, + FcFontSet **sets, + int nsets, + FcPattern *p, + FcBool trim, + FcCharSet **csp, + FcResult *result); + +FcPublic FcFontSet * +FcFontSort (FcConfig *config, + FcPattern *p, + FcBool trim, + FcCharSet **csp, + FcResult *result); + +FcPublic void +FcFontSetSortDestroy (FcFontSet *fs); + +/* fcmatrix.c */ +FcPublic FcMatrix * +FcMatrixCopy (const FcMatrix *mat); + +FcPublic FcBool +FcMatrixEqual (const FcMatrix *mat1, const FcMatrix *mat2); + +FcPublic void +FcMatrixMultiply (FcMatrix *result, const FcMatrix *a, const FcMatrix *b); + +FcPublic void +FcMatrixRotate (FcMatrix *m, double c, double s); + +FcPublic void +FcMatrixScale (FcMatrix *m, double sx, double sy); + +FcPublic void +FcMatrixShear (FcMatrix *m, double sh, double sv); + +/* fcname.c */ + +/* Deprecated. Does nothing. Returns FcFalse. */ +FcPublic FcBool +FcNameRegisterObjectTypes (const FcObjectType *types, int ntype); + +/* Deprecated. Does nothing. Returns FcFalse. */ +FcPublic FcBool +FcNameUnregisterObjectTypes (const FcObjectType *types, int ntype); + +FcPublic const FcObjectType * +FcNameGetObjectType (const char *object); + +/* Deprecated. Does nothing. Returns FcFalse. */ +FcPublic FcBool +FcNameRegisterConstants (const FcConstant *consts, int nconsts); + +/* Deprecated. Does nothing. Returns FcFalse. */ +FcPublic FcBool +FcNameUnregisterConstants (const FcConstant *consts, int nconsts); + +FcPublic const FcConstant * +FcNameGetConstant (const FcChar8 *string); + +FcPublic const FcConstant * +FcNameGetConstantFor (const FcChar8 *string, const char *object); + +FcPublic FcBool +FcNameConstant (const FcChar8 *string, int *result); + +FcPublic const FcChar8 * +FcNameGetConstantNameFrom (const char *object, int value); + +FcPublic FcPattern * +FcNameParse (const FcChar8 *name); + +FcPublic FcChar8 * +FcNameUnparse (FcPattern *pat); + +/* fcpat.c */ +FcPublic FcPattern * +FcPatternCreate (void); + +FcPublic FcPattern * +FcPatternDuplicate (const FcPattern *p); + +FcPublic void +FcPatternReference (FcPattern *p); + +FcPublic FcPattern * +FcPatternFilter (FcPattern *p, const FcObjectSet *os); + +FcPublic void +FcValueDestroy (FcValue v); + +FcPublic FcBool +FcValueEqual (FcValue va, FcValue vb); + +FcPublic FcValue +FcValueSave (FcValue v); + +FcPublic void +FcPatternDestroy (FcPattern *p); + +FcPublic int +FcPatternObjectCount (const FcPattern *pat); + +FcPublic FcBool +FcPatternEqual (const FcPattern *pa, const FcPattern *pb); + +FcPublic FcBool +FcPatternEqualSubset (const FcPattern *pa, const FcPattern *pb, const FcObjectSet *os); + +FcPublic FcChar32 +FcPatternHash (const FcPattern *p); + +FcPublic FcBool +FcPatternAdd (FcPattern *p, const char *object, FcValue value, FcBool append); + +FcPublic FcBool +FcPatternAddWeak (FcPattern *p, const char *object, FcValue value, FcBool append); + +FcPublic FcResult +FcPatternGet (const FcPattern *p, const char *object, int id, FcValue *v); + +FcPublic FcResult +FcPatternGetWithBinding (const FcPattern *p, const char *object, int id, FcValue *v, FcValueBinding *b); + +FcPublic FcBool +FcPatternDel (FcPattern *p, const char *object); + +FcPublic FcBool +FcPatternRemove (FcPattern *p, const char *object, int id); + +FcPublic FcBool +FcPatternAddInteger (FcPattern *p, const char *object, int i); + +FcPublic FcBool +FcPatternAddDouble (FcPattern *p, const char *object, double d); + +FcPublic FcBool +FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s); + +FcPublic FcBool +FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *s); + +FcPublic FcBool +FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c); + +FcPublic FcBool +FcPatternAddBool (FcPattern *p, const char *object, FcBool b); + +FcPublic FcBool +FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls); + +FcPublic FcBool +FcPatternAddRange (FcPattern *p, const char *object, const FcRange *r); + +FcPublic FcResult +FcPatternGetInteger (const FcPattern *p, const char *object, int n, int *i); + +FcPublic FcResult +FcPatternGetDouble (const FcPattern *p, const char *object, int n, double *d); + +FcPublic FcResult +FcPatternGetString (const FcPattern *p, const char *object, int n, FcChar8 **s); + +FcPublic FcResult +FcPatternGetMatrix (const FcPattern *p, const char *object, int n, FcMatrix **s); + +FcPublic FcResult +FcPatternGetCharSet (const FcPattern *p, const char *object, int n, FcCharSet **c); + +FcPublic FcResult +FcPatternGetBool (const FcPattern *p, const char *object, int n, FcBool *b); + +FcPublic FcResult +FcPatternGetLangSet (const FcPattern *p, const char *object, int n, FcLangSet **ls); + +FcPublic FcResult +FcPatternGetRange (const FcPattern *p, const char *object, int id, FcRange **r); + +FcPublic FcPattern * +FcPatternVaBuild (FcPattern *p, va_list va); + +FcPublic FcPattern * +FcPatternBuild (FcPattern *p, ...) FC_ATTRIBUTE_SENTINEL (0); + +FcPublic FcChar8 * +FcPatternFormat (FcPattern *pat, const FcChar8 *format); + +/* fcrange.c */ +FcPublic FcRange * +FcRangeCreateDouble (double begin, double end); + +FcPublic FcRange * +FcRangeCreateInteger (FcChar32 begin, FcChar32 end); + +FcPublic void +FcRangeDestroy (FcRange *range); + +FcPublic FcRange * +FcRangeCopy (const FcRange *r); + +FcPublic FcBool +FcRangeGetDouble (const FcRange *range, double *begin, double *end); + +FcPublic void +FcPatternIterStart (const FcPattern *pat, FcPatternIter *iter); + +FcPublic FcBool +FcPatternIterNext (const FcPattern *pat, FcPatternIter *iter); + +FcPublic FcBool +FcPatternIterEqual (const FcPattern *p1, FcPatternIter *i1, + const FcPattern *p2, FcPatternIter *i2); + +FcPublic FcBool +FcPatternFindIter (const FcPattern *pat, FcPatternIter *iter, const char *object); + +FcPublic FcBool +FcPatternIterIsValid (const FcPattern *pat, FcPatternIter *iter); + +FcPublic const char * +FcPatternIterGetObject (const FcPattern *pat, FcPatternIter *iter); + +FcPublic int +FcPatternIterValueCount (const FcPattern *pat, FcPatternIter *iter); + +FcPublic FcResult +FcPatternIterGetValue (const FcPattern *pat, FcPatternIter *iter, int id, FcValue *v, FcValueBinding *b); + +/* fcweight.c */ + +FcPublic int +FcWeightFromOpenType (int ot_weight); + +FcPublic double +FcWeightFromOpenTypeDouble (double ot_weight); + +FcPublic int +FcWeightToOpenType (int fc_weight); + +FcPublic double +FcWeightToOpenTypeDouble (double fc_weight); + +/* fcstr.c */ + +FcPublic FcChar8 * +FcStrCopy (const FcChar8 *s); + +FcPublic FcChar8 * +FcStrCopyFilename (const FcChar8 *s); + +FcPublic FcChar8 * +FcStrPlus (const FcChar8 *s1, const FcChar8 *s2); + +FcPublic void +FcStrFree (FcChar8 *s); + +/* These are ASCII only, suitable only for pattern element names */ +#define FcIsUpper(c) ((0101 <= (c) && (c) <= 0132)) +#define FcIsLower(c) ((0141 <= (c) && (c) <= 0172)) +#define FcToLower(c) (FcIsUpper (c) ? (c) - 0101 + 0141 : (c)) + +FcPublic FcChar8 * +FcStrDowncase (const FcChar8 *s); + +FcPublic int +FcStrCmpIgnoreCase (const FcChar8 *s1, const FcChar8 *s2); + +FcPublic int +FcStrCmp (const FcChar8 *s1, const FcChar8 *s2); + +FcPublic const FcChar8 * +FcStrStrIgnoreCase (const FcChar8 *s1, const FcChar8 *s2); + +FcPublic const FcChar8 * +FcStrStr (const FcChar8 *s1, const FcChar8 *s2); + +FcPublic int +FcUtf8ToUcs4 (const FcChar8 *src_orig, + FcChar32 *dst, + int len); + +FcPublic FcBool +FcUtf8Len (const FcChar8 *string, + int len, + int *nchar, + int *wchar); + +#define FC_UTF8_MAX_LEN 6 + +FcPublic int +FcUcs4ToUtf8 (FcChar32 ucs4, + FcChar8 dest[FC_UTF8_MAX_LEN]); + +FcPublic int +FcUtf16ToUcs4 (const FcChar8 *src_orig, + FcEndian endian, + FcChar32 *dst, + int len); /* in bytes */ + +FcPublic FcBool +FcUtf16Len (const FcChar8 *string, + FcEndian endian, + int len, /* in bytes */ + int *nchar, + int *wchar); + +FcPublic FcChar8 * +FcStrBuildFilename (const FcChar8 *path, + ...); + +FcPublic FcChar8 * +FcStrDirname (const FcChar8 *file); + +FcPublic FcChar8 * +FcStrBasename (const FcChar8 *file); + +FcPublic FcStrSet * +FcStrSetCreate (void); + +FcPublic FcBool +FcStrSetMember (FcStrSet *set, const FcChar8 *s); + +FcPublic FcBool +FcStrSetEqual (FcStrSet *sa, FcStrSet *sb); + +FcPublic FcBool +FcStrSetAdd (FcStrSet *set, const FcChar8 *s); + +FcPublic FcBool +FcStrSetAddFilename (FcStrSet *set, const FcChar8 *s); + +FcPublic FcBool +FcStrSetDel (FcStrSet *set, const FcChar8 *s); + +FcPublic void +FcStrSetDestroy (FcStrSet *set); + +FcPublic FcStrList * +FcStrListCreate (FcStrSet *set); + +FcPublic void +FcStrListFirst (FcStrList *list); + +FcPublic FcChar8 * +FcStrListNext (FcStrList *list); + +FcPublic void +FcStrListDone (FcStrList *list); + +/* fcxml.c */ +FcPublic FcBool +FcConfigParseAndLoad (FcConfig *config, const FcChar8 *file, FcBool complain); + +FcPublic FcBool +FcConfigParseAndLoadFromMemory (FcConfig *config, + const FcChar8 *buffer, + FcBool complain); + +/* fcconffile.c */ +FcPublic FcChar8 * +FcConfigFileGenerate (FcConfig *config, + FcPattern *pat, + const FcChar8 *font_path); + +_FCFUNCPROTOEND + +#undef FC_ATTRIBUTE_SENTINEL +#undef FC_ATTRIBUTE_MAY_ALIAS + +#ifndef _FCINT_H_ + +/* + * Deprecated functions are placed here to help users fix their code without + * digging through documentation + */ + +# define FcConfigGetRescanInverval FcConfigGetRescanInverval_REPLACE_BY_FcConfigGetRescanInterval +# define FcConfigSetRescanInverval FcConfigSetRescanInverval_REPLACE_BY_FcConfigSetRescanInterval + +#endif + +#endif /* _FONTCONFIG_H_ */ diff --git a/pkg/fontconfig/override/include/fcalias.h b/pkg/fontconfig/override/include/fcalias.h deleted file mode 100644 index e69de29bb..000000000 diff --git a/pkg/fontconfig/override/include/fcaliastail.h b/pkg/fontconfig/override/include/fcaliastail.h deleted file mode 100644 index e69de29bb..000000000 diff --git a/pkg/fontconfig/override/include/fcftalias.h b/pkg/fontconfig/override/include/fcftalias.h deleted file mode 100644 index e69de29bb..000000000 diff --git a/pkg/fontconfig/override/include/fcftaliastail.h b/pkg/fontconfig/override/include/fcftaliastail.h deleted file mode 100644 index e69de29bb..000000000 diff --git a/pkg/fontconfig/override/src/fcalias.h b/pkg/fontconfig/override/src/fcalias.h new file mode 100644 index 000000000..8746ce574 --- /dev/null +++ b/pkg/fontconfig/override/src/fcalias.h @@ -0,0 +1,472 @@ +extern __typeof (FcBlanksCreate) IA__FcBlanksCreate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcBlanksCreate IA__FcBlanksCreate +extern __typeof (FcBlanksDestroy) IA__FcBlanksDestroy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcBlanksDestroy IA__FcBlanksDestroy +extern __typeof (FcBlanksAdd) IA__FcBlanksAdd FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcBlanksAdd IA__FcBlanksAdd +extern __typeof (FcBlanksIsMember) IA__FcBlanksIsMember FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcBlanksIsMember IA__FcBlanksIsMember +extern __typeof (FcCacheCopySet) IA__FcCacheCopySet FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCacheCopySet IA__FcCacheCopySet +extern __typeof (FcCacheNumSubdir) IA__FcCacheNumSubdir FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCacheNumSubdir IA__FcCacheNumSubdir +extern __typeof (FcCacheNumFont) IA__FcCacheNumFont FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCacheNumFont IA__FcCacheNumFont +extern __typeof (FcDirCacheUnlink) IA__FcDirCacheUnlink FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcDirCacheUnlink IA__FcDirCacheUnlink +extern __typeof (FcDirCacheValid) IA__FcDirCacheValid FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcDirCacheValid IA__FcDirCacheValid +extern __typeof (FcDirCacheClean) IA__FcDirCacheClean FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcDirCacheClean IA__FcDirCacheClean +extern __typeof (FcCacheCreateTagFile) IA__FcCacheCreateTagFile FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCacheCreateTagFile IA__FcCacheCreateTagFile +extern __typeof (FcDirCacheCreateUUID) IA__FcDirCacheCreateUUID FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcDirCacheCreateUUID IA__FcDirCacheCreateUUID +extern __typeof (FcDirCacheDeleteUUID) IA__FcDirCacheDeleteUUID FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcDirCacheDeleteUUID IA__FcDirCacheDeleteUUID +extern __typeof (FcConfigHome) IA__FcConfigHome FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigHome IA__FcConfigHome +extern __typeof (FcConfigEnableHome) IA__FcConfigEnableHome FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigEnableHome IA__FcConfigEnableHome +extern __typeof (FcConfigGetFilename) IA__FcConfigGetFilename FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetFilename IA__FcConfigGetFilename +extern __typeof (FcConfigFilename) IA__FcConfigFilename FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigFilename IA__FcConfigFilename +extern __typeof (FcConfigCreate) IA__FcConfigCreate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigCreate IA__FcConfigCreate +extern __typeof (FcConfigReference) IA__FcConfigReference FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigReference IA__FcConfigReference +extern __typeof (FcConfigDestroy) IA__FcConfigDestroy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigDestroy IA__FcConfigDestroy +extern __typeof (FcConfigSetCurrent) IA__FcConfigSetCurrent FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigSetCurrent IA__FcConfigSetCurrent +extern __typeof (FcConfigGetCurrent) IA__FcConfigGetCurrent FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetCurrent IA__FcConfigGetCurrent +extern __typeof (FcConfigUptoDate) IA__FcConfigUptoDate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigUptoDate IA__FcConfigUptoDate +extern __typeof (FcConfigBuildFonts) IA__FcConfigBuildFonts FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigBuildFonts IA__FcConfigBuildFonts +extern __typeof (FcConfigGetFontDirs) IA__FcConfigGetFontDirs FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetFontDirs IA__FcConfigGetFontDirs +extern __typeof (FcConfigGetConfigDirs) IA__FcConfigGetConfigDirs FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetConfigDirs IA__FcConfigGetConfigDirs +extern __typeof (FcConfigGetConfigFiles) IA__FcConfigGetConfigFiles FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetConfigFiles IA__FcConfigGetConfigFiles +extern __typeof (FcConfigGetCache) IA__FcConfigGetCache FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetCache IA__FcConfigGetCache +extern __typeof (FcConfigGetBlanks) IA__FcConfigGetBlanks FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetBlanks IA__FcConfigGetBlanks +extern __typeof (FcConfigGetCacheDirs) IA__FcConfigGetCacheDirs FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetCacheDirs IA__FcConfigGetCacheDirs +extern __typeof (FcConfigGetRescanInterval) IA__FcConfigGetRescanInterval FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetRescanInterval IA__FcConfigGetRescanInterval +extern __typeof (FcConfigSetRescanInterval) IA__FcConfigSetRescanInterval FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigSetRescanInterval IA__FcConfigSetRescanInterval +extern __typeof (FcConfigGetFonts) IA__FcConfigGetFonts FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetFonts IA__FcConfigGetFonts +extern __typeof (FcConfigAcceptFont) IA__FcConfigAcceptFont FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigAcceptFont IA__FcConfigAcceptFont +extern __typeof (FcConfigAcceptFilename) IA__FcConfigAcceptFilename FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigAcceptFilename IA__FcConfigAcceptFilename +extern __typeof (FcConfigAcceptFilter) IA__FcConfigAcceptFilter FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigAcceptFilter IA__FcConfigAcceptFilter +extern __typeof (FcConfigAppFontAddFile) IA__FcConfigAppFontAddFile FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigAppFontAddFile IA__FcConfigAppFontAddFile +extern __typeof (FcConfigAppFontAddDir) IA__FcConfigAppFontAddDir FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigAppFontAddDir IA__FcConfigAppFontAddDir +extern __typeof (FcConfigAppFontClear) IA__FcConfigAppFontClear FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigAppFontClear IA__FcConfigAppFontClear +extern __typeof (FcConfigPreferAppFont) IA__FcConfigPreferAppFont FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigPreferAppFont IA__FcConfigPreferAppFont +extern __typeof (FcConfigSetWarningFlags) IA__FcConfigSetWarningFlags FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigSetWarningFlags IA__FcConfigSetWarningFlags +extern __typeof (FcConfigGetWarningFlags) IA__FcConfigGetWarningFlags FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetWarningFlags IA__FcConfigGetWarningFlags +extern __typeof (FcConfigSubstituteWithPat) IA__FcConfigSubstituteWithPat FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigSubstituteWithPat IA__FcConfigSubstituteWithPat +extern __typeof (FcConfigSubstitute) IA__FcConfigSubstitute FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigSubstitute IA__FcConfigSubstitute +extern __typeof (FcConfigGetSysRoot) IA__FcConfigGetSysRoot FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetSysRoot IA__FcConfigGetSysRoot +extern __typeof (FcConfigSetSysRoot) IA__FcConfigSetSysRoot FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigSetSysRoot IA__FcConfigSetSysRoot +extern __typeof (FcConfigSetFontSetFilter) IA__FcConfigSetFontSetFilter FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigSetFontSetFilter IA__FcConfigSetFontSetFilter +extern __typeof (FcConfigFileInfoIterInit) IA__FcConfigFileInfoIterInit FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigFileInfoIterInit IA__FcConfigFileInfoIterInit +extern __typeof (FcConfigFileInfoIterNext) IA__FcConfigFileInfoIterNext FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigFileInfoIterNext IA__FcConfigFileInfoIterNext +extern __typeof (FcConfigFileInfoIterGet) IA__FcConfigFileInfoIterGet FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigFileInfoIterGet IA__FcConfigFileInfoIterGet +extern __typeof (FcCharSetCreate) IA__FcCharSetCreate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetCreate IA__FcCharSetCreate +extern __typeof (FcCharSetNew) IA__FcCharSetNew FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetNew IA__FcCharSetNew +extern __typeof (FcCharSetDestroy) IA__FcCharSetDestroy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetDestroy IA__FcCharSetDestroy +extern __typeof (FcCharSetAddChar) IA__FcCharSetAddChar FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetAddChar IA__FcCharSetAddChar +extern __typeof (FcCharSetDelChar) IA__FcCharSetDelChar FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetDelChar IA__FcCharSetDelChar +extern __typeof (FcCharSetCopy) IA__FcCharSetCopy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetCopy IA__FcCharSetCopy +extern __typeof (FcCharSetEqual) IA__FcCharSetEqual FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetEqual IA__FcCharSetEqual +extern __typeof (FcCharSetIntersect) IA__FcCharSetIntersect FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetIntersect IA__FcCharSetIntersect +extern __typeof (FcCharSetUnion) IA__FcCharSetUnion FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetUnion IA__FcCharSetUnion +extern __typeof (FcCharSetSubtract) IA__FcCharSetSubtract FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetSubtract IA__FcCharSetSubtract +extern __typeof (FcCharSetMerge) IA__FcCharSetMerge FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetMerge IA__FcCharSetMerge +extern __typeof (FcCharSetHasChar) IA__FcCharSetHasChar FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetHasChar IA__FcCharSetHasChar +extern __typeof (FcCharSetCount) IA__FcCharSetCount FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetCount IA__FcCharSetCount +extern __typeof (FcCharSetIntersectCount) IA__FcCharSetIntersectCount FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetIntersectCount IA__FcCharSetIntersectCount +extern __typeof (FcCharSetSubtractCount) IA__FcCharSetSubtractCount FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetSubtractCount IA__FcCharSetSubtractCount +extern __typeof (FcCharSetIsSubset) IA__FcCharSetIsSubset FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetIsSubset IA__FcCharSetIsSubset +extern __typeof (FcCharSetFirstPage) IA__FcCharSetFirstPage FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetFirstPage IA__FcCharSetFirstPage +extern __typeof (FcCharSetNextPage) IA__FcCharSetNextPage FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetNextPage IA__FcCharSetNextPage +extern __typeof (FcCharSetCoverage) IA__FcCharSetCoverage FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcCharSetCoverage IA__FcCharSetCoverage +extern __typeof (FcValuePrint) IA__FcValuePrint FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcValuePrint IA__FcValuePrint +extern __typeof (FcPatternPrint) IA__FcPatternPrint FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternPrint IA__FcPatternPrint +extern __typeof (FcFontSetPrint) IA__FcFontSetPrint FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFontSetPrint IA__FcFontSetPrint +extern __typeof (FcConfigGetDefaultLangs) IA__FcConfigGetDefaultLangs FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetDefaultLangs IA__FcConfigGetDefaultLangs +extern __typeof (FcGetDefaultLangs) IA__FcGetDefaultLangs FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcGetDefaultLangs IA__FcGetDefaultLangs +extern __typeof (FcConfigSetDefaultSubstitute) IA__FcConfigSetDefaultSubstitute FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigSetDefaultSubstitute IA__FcConfigSetDefaultSubstitute +extern __typeof (FcDefaultSubstitute) IA__FcDefaultSubstitute FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcDefaultSubstitute IA__FcDefaultSubstitute +extern __typeof (FcFileIsDir) IA__FcFileIsDir FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFileIsDir IA__FcFileIsDir +extern __typeof (FcFileScan) IA__FcFileScan FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFileScan IA__FcFileScan +extern __typeof (FcDirScan) IA__FcDirScan FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcDirScan IA__FcDirScan +extern __typeof (FcDirSave) IA__FcDirSave FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcDirSave IA__FcDirSave +extern __typeof (FcDirCacheLoad) IA__FcDirCacheLoad FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcDirCacheLoad IA__FcDirCacheLoad +extern __typeof (FcDirCacheRescan) IA__FcDirCacheRescan FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcDirCacheRescan IA__FcDirCacheRescan +extern __typeof (FcDirCacheRead) IA__FcDirCacheRead FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcDirCacheRead IA__FcDirCacheRead +extern __typeof (FcDirCacheLoadFile) IA__FcDirCacheLoadFile FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcDirCacheLoadFile IA__FcDirCacheLoadFile +extern __typeof (FcDirCacheUnload) IA__FcDirCacheUnload FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcDirCacheUnload IA__FcDirCacheUnload +extern __typeof (FcFontSetCreate) IA__FcFontSetCreate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFontSetCreate IA__FcFontSetCreate +extern __typeof (FcFontSetDestroy) IA__FcFontSetDestroy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFontSetDestroy IA__FcFontSetDestroy +extern __typeof (FcFontSetAdd) IA__FcFontSetAdd FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFontSetAdd IA__FcFontSetAdd +extern __typeof (FcInitLoadConfig) IA__FcInitLoadConfig FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcInitLoadConfig IA__FcInitLoadConfig +extern __typeof (FcInitLoadConfigAndFonts) IA__FcInitLoadConfigAndFonts FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcInitLoadConfigAndFonts IA__FcInitLoadConfigAndFonts +extern __typeof (FcInit) IA__FcInit FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcInit IA__FcInit +extern __typeof (FcFini) IA__FcFini FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFini IA__FcFini +extern __typeof (FcGetVersion) IA__FcGetVersion FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcGetVersion IA__FcGetVersion +extern __typeof (FcInitReinitialize) IA__FcInitReinitialize FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcInitReinitialize IA__FcInitReinitialize +extern __typeof (FcInitBringUptoDate) IA__FcInitBringUptoDate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcInitBringUptoDate IA__FcInitBringUptoDate +extern __typeof (FcGetLangs) IA__FcGetLangs FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcGetLangs IA__FcGetLangs +extern __typeof (FcLangNormalize) IA__FcLangNormalize FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangNormalize IA__FcLangNormalize +extern __typeof (FcLangGetCharSet) IA__FcLangGetCharSet FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangGetCharSet IA__FcLangGetCharSet +extern __typeof (FcLangSetCreate) IA__FcLangSetCreate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangSetCreate IA__FcLangSetCreate +extern __typeof (FcLangSetDestroy) IA__FcLangSetDestroy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangSetDestroy IA__FcLangSetDestroy +extern __typeof (FcLangSetCopy) IA__FcLangSetCopy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangSetCopy IA__FcLangSetCopy +extern __typeof (FcLangSetAdd) IA__FcLangSetAdd FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangSetAdd IA__FcLangSetAdd +extern __typeof (FcLangSetDel) IA__FcLangSetDel FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangSetDel IA__FcLangSetDel +extern __typeof (FcLangSetHasLang) IA__FcLangSetHasLang FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangSetHasLang IA__FcLangSetHasLang +extern __typeof (FcLangSetCompare) IA__FcLangSetCompare FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangSetCompare IA__FcLangSetCompare +extern __typeof (FcLangSetContains) IA__FcLangSetContains FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangSetContains IA__FcLangSetContains +extern __typeof (FcLangSetEqual) IA__FcLangSetEqual FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangSetEqual IA__FcLangSetEqual +extern __typeof (FcLangSetHash) IA__FcLangSetHash FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangSetHash IA__FcLangSetHash +extern __typeof (FcLangSetGetLangs) IA__FcLangSetGetLangs FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangSetGetLangs IA__FcLangSetGetLangs +extern __typeof (FcLangSetUnion) IA__FcLangSetUnion FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangSetUnion IA__FcLangSetUnion +extern __typeof (FcLangSetSubtract) IA__FcLangSetSubtract FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcLangSetSubtract IA__FcLangSetSubtract +extern __typeof (FcObjectSetCreate) IA__FcObjectSetCreate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcObjectSetCreate IA__FcObjectSetCreate +extern __typeof (FcObjectSetAdd) IA__FcObjectSetAdd FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcObjectSetAdd IA__FcObjectSetAdd +extern __typeof (FcObjectSetDestroy) IA__FcObjectSetDestroy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcObjectSetDestroy IA__FcObjectSetDestroy +extern __typeof (FcObjectSetVaBuild) IA__FcObjectSetVaBuild FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcObjectSetVaBuild IA__FcObjectSetVaBuild +extern __typeof (FcObjectSetBuild) IA__FcObjectSetBuild FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcObjectSetBuild IA__FcObjectSetBuild +extern __typeof (FcFontSetList) IA__FcFontSetList FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFontSetList IA__FcFontSetList +extern __typeof (FcFontList) IA__FcFontList FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFontList IA__FcFontList +extern __typeof (FcAtomicCreate) IA__FcAtomicCreate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcAtomicCreate IA__FcAtomicCreate +extern __typeof (FcAtomicLock) IA__FcAtomicLock FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcAtomicLock IA__FcAtomicLock +extern __typeof (FcAtomicNewFile) IA__FcAtomicNewFile FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcAtomicNewFile IA__FcAtomicNewFile +extern __typeof (FcAtomicOrigFile) IA__FcAtomicOrigFile FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcAtomicOrigFile IA__FcAtomicOrigFile +extern __typeof (FcAtomicReplaceOrig) IA__FcAtomicReplaceOrig FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcAtomicReplaceOrig IA__FcAtomicReplaceOrig +extern __typeof (FcAtomicDeleteNew) IA__FcAtomicDeleteNew FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcAtomicDeleteNew IA__FcAtomicDeleteNew +extern __typeof (FcAtomicUnlock) IA__FcAtomicUnlock FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcAtomicUnlock IA__FcAtomicUnlock +extern __typeof (FcAtomicDestroy) IA__FcAtomicDestroy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcAtomicDestroy IA__FcAtomicDestroy +extern __typeof (FcFontSetMatch) IA__FcFontSetMatch FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFontSetMatch IA__FcFontSetMatch +extern __typeof (FcFontMatch) IA__FcFontMatch FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFontMatch IA__FcFontMatch +extern __typeof (FcFontRenderPrepare) IA__FcFontRenderPrepare FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFontRenderPrepare IA__FcFontRenderPrepare +extern __typeof (FcFontSetSort) IA__FcFontSetSort FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFontSetSort IA__FcFontSetSort +extern __typeof (FcFontSort) IA__FcFontSort FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFontSort IA__FcFontSort +extern __typeof (FcFontSetSortDestroy) IA__FcFontSetSortDestroy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFontSetSortDestroy IA__FcFontSetSortDestroy +extern __typeof (FcMatrixCopy) IA__FcMatrixCopy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcMatrixCopy IA__FcMatrixCopy +extern __typeof (FcMatrixEqual) IA__FcMatrixEqual FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcMatrixEqual IA__FcMatrixEqual +extern __typeof (FcMatrixMultiply) IA__FcMatrixMultiply FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcMatrixMultiply IA__FcMatrixMultiply +extern __typeof (FcMatrixRotate) IA__FcMatrixRotate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcMatrixRotate IA__FcMatrixRotate +extern __typeof (FcMatrixScale) IA__FcMatrixScale FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcMatrixScale IA__FcMatrixScale +extern __typeof (FcMatrixShear) IA__FcMatrixShear FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcMatrixShear IA__FcMatrixShear +extern __typeof (FcNameRegisterObjectTypes) IA__FcNameRegisterObjectTypes FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcNameRegisterObjectTypes IA__FcNameRegisterObjectTypes +extern __typeof (FcNameUnregisterObjectTypes) IA__FcNameUnregisterObjectTypes FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcNameUnregisterObjectTypes IA__FcNameUnregisterObjectTypes +extern __typeof (FcNameGetObjectType) IA__FcNameGetObjectType FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcNameGetObjectType IA__FcNameGetObjectType +extern __typeof (FcNameRegisterConstants) IA__FcNameRegisterConstants FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcNameRegisterConstants IA__FcNameRegisterConstants +extern __typeof (FcNameUnregisterConstants) IA__FcNameUnregisterConstants FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcNameUnregisterConstants IA__FcNameUnregisterConstants +extern __typeof (FcNameGetConstant) IA__FcNameGetConstant FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcNameGetConstant IA__FcNameGetConstant +extern __typeof (FcNameGetConstantFor) IA__FcNameGetConstantFor FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcNameGetConstantFor IA__FcNameGetConstantFor +extern __typeof (FcNameConstant) IA__FcNameConstant FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcNameConstant IA__FcNameConstant +extern __typeof (FcNameGetConstantNameFrom) IA__FcNameGetConstantNameFrom FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcNameGetConstantNameFrom IA__FcNameGetConstantNameFrom +extern __typeof (FcNameParse) IA__FcNameParse FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcNameParse IA__FcNameParse +extern __typeof (FcNameUnparse) IA__FcNameUnparse FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcNameUnparse IA__FcNameUnparse +extern __typeof (FcPatternCreate) IA__FcPatternCreate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternCreate IA__FcPatternCreate +extern __typeof (FcPatternDuplicate) IA__FcPatternDuplicate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternDuplicate IA__FcPatternDuplicate +extern __typeof (FcPatternReference) IA__FcPatternReference FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternReference IA__FcPatternReference +extern __typeof (FcPatternFilter) IA__FcPatternFilter FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternFilter IA__FcPatternFilter +extern __typeof (FcValueDestroy) IA__FcValueDestroy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcValueDestroy IA__FcValueDestroy +extern __typeof (FcValueEqual) IA__FcValueEqual FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcValueEqual IA__FcValueEqual +extern __typeof (FcValueSave) IA__FcValueSave FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcValueSave IA__FcValueSave +extern __typeof (FcPatternDestroy) IA__FcPatternDestroy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternDestroy IA__FcPatternDestroy +extern __typeof (FcPatternObjectCount) IA__FcPatternObjectCount FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternObjectCount IA__FcPatternObjectCount +extern __typeof (FcPatternEqual) IA__FcPatternEqual FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternEqual IA__FcPatternEqual +extern __typeof (FcPatternEqualSubset) IA__FcPatternEqualSubset FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternEqualSubset IA__FcPatternEqualSubset +extern __typeof (FcPatternHash) IA__FcPatternHash FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternHash IA__FcPatternHash +extern __typeof (FcPatternAdd) IA__FcPatternAdd FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternAdd IA__FcPatternAdd +extern __typeof (FcPatternAddWeak) IA__FcPatternAddWeak FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternAddWeak IA__FcPatternAddWeak +extern __typeof (FcPatternGet) IA__FcPatternGet FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternGet IA__FcPatternGet +extern __typeof (FcPatternGetWithBinding) IA__FcPatternGetWithBinding FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternGetWithBinding IA__FcPatternGetWithBinding +extern __typeof (FcPatternDel) IA__FcPatternDel FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternDel IA__FcPatternDel +extern __typeof (FcPatternRemove) IA__FcPatternRemove FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternRemove IA__FcPatternRemove +extern __typeof (FcPatternAddInteger) IA__FcPatternAddInteger FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternAddInteger IA__FcPatternAddInteger +extern __typeof (FcPatternAddDouble) IA__FcPatternAddDouble FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternAddDouble IA__FcPatternAddDouble +extern __typeof (FcPatternAddString) IA__FcPatternAddString FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternAddString IA__FcPatternAddString +extern __typeof (FcPatternAddMatrix) IA__FcPatternAddMatrix FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternAddMatrix IA__FcPatternAddMatrix +extern __typeof (FcPatternAddCharSet) IA__FcPatternAddCharSet FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternAddCharSet IA__FcPatternAddCharSet +extern __typeof (FcPatternAddBool) IA__FcPatternAddBool FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternAddBool IA__FcPatternAddBool +extern __typeof (FcPatternAddLangSet) IA__FcPatternAddLangSet FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternAddLangSet IA__FcPatternAddLangSet +extern __typeof (FcPatternAddRange) IA__FcPatternAddRange FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternAddRange IA__FcPatternAddRange +extern __typeof (FcPatternGetInteger) IA__FcPatternGetInteger FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternGetInteger IA__FcPatternGetInteger +extern __typeof (FcPatternGetDouble) IA__FcPatternGetDouble FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternGetDouble IA__FcPatternGetDouble +extern __typeof (FcPatternGetString) IA__FcPatternGetString FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternGetString IA__FcPatternGetString +extern __typeof (FcPatternGetMatrix) IA__FcPatternGetMatrix FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternGetMatrix IA__FcPatternGetMatrix +extern __typeof (FcPatternGetCharSet) IA__FcPatternGetCharSet FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternGetCharSet IA__FcPatternGetCharSet +extern __typeof (FcPatternGetBool) IA__FcPatternGetBool FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternGetBool IA__FcPatternGetBool +extern __typeof (FcPatternGetLangSet) IA__FcPatternGetLangSet FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternGetLangSet IA__FcPatternGetLangSet +extern __typeof (FcPatternGetRange) IA__FcPatternGetRange FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternGetRange IA__FcPatternGetRange +extern __typeof (FcPatternVaBuild) IA__FcPatternVaBuild FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternVaBuild IA__FcPatternVaBuild +extern __typeof (FcPatternBuild) IA__FcPatternBuild FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternBuild IA__FcPatternBuild +extern __typeof (FcPatternFormat) IA__FcPatternFormat FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternFormat IA__FcPatternFormat +extern __typeof (FcRangeCreateDouble) IA__FcRangeCreateDouble FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcRangeCreateDouble IA__FcRangeCreateDouble +extern __typeof (FcRangeCreateInteger) IA__FcRangeCreateInteger FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcRangeCreateInteger IA__FcRangeCreateInteger +extern __typeof (FcRangeDestroy) IA__FcRangeDestroy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcRangeDestroy IA__FcRangeDestroy +extern __typeof (FcRangeCopy) IA__FcRangeCopy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcRangeCopy IA__FcRangeCopy +extern __typeof (FcRangeGetDouble) IA__FcRangeGetDouble FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcRangeGetDouble IA__FcRangeGetDouble +extern __typeof (FcPatternIterStart) IA__FcPatternIterStart FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternIterStart IA__FcPatternIterStart +extern __typeof (FcPatternIterNext) IA__FcPatternIterNext FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternIterNext IA__FcPatternIterNext +extern __typeof (FcPatternIterEqual) IA__FcPatternIterEqual FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternIterEqual IA__FcPatternIterEqual +extern __typeof (FcPatternFindIter) IA__FcPatternFindIter FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternFindIter IA__FcPatternFindIter +extern __typeof (FcPatternIterIsValid) IA__FcPatternIterIsValid FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternIterIsValid IA__FcPatternIterIsValid +extern __typeof (FcPatternIterGetObject) IA__FcPatternIterGetObject FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternIterGetObject IA__FcPatternIterGetObject +extern __typeof (FcPatternIterValueCount) IA__FcPatternIterValueCount FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternIterValueCount IA__FcPatternIterValueCount +extern __typeof (FcPatternIterGetValue) IA__FcPatternIterGetValue FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternIterGetValue IA__FcPatternIterGetValue +extern __typeof (FcWeightFromOpenType) IA__FcWeightFromOpenType FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcWeightFromOpenType IA__FcWeightFromOpenType +extern __typeof (FcWeightFromOpenTypeDouble) IA__FcWeightFromOpenTypeDouble FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcWeightFromOpenTypeDouble IA__FcWeightFromOpenTypeDouble +extern __typeof (FcWeightToOpenType) IA__FcWeightToOpenType FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcWeightToOpenType IA__FcWeightToOpenType +extern __typeof (FcWeightToOpenTypeDouble) IA__FcWeightToOpenTypeDouble FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcWeightToOpenTypeDouble IA__FcWeightToOpenTypeDouble +extern __typeof (FcStrCopy) IA__FcStrCopy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrCopy IA__FcStrCopy +extern __typeof (FcStrCopyFilename) IA__FcStrCopyFilename FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrCopyFilename IA__FcStrCopyFilename +extern __typeof (FcStrPlus) IA__FcStrPlus FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrPlus IA__FcStrPlus +extern __typeof (FcStrFree) IA__FcStrFree FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrFree IA__FcStrFree +extern __typeof (FcStrDowncase) IA__FcStrDowncase FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrDowncase IA__FcStrDowncase +extern __typeof (FcStrCmpIgnoreCase) IA__FcStrCmpIgnoreCase FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrCmpIgnoreCase IA__FcStrCmpIgnoreCase +extern __typeof (FcStrCmp) IA__FcStrCmp FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrCmp IA__FcStrCmp +extern __typeof (FcStrStrIgnoreCase) IA__FcStrStrIgnoreCase FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrStrIgnoreCase IA__FcStrStrIgnoreCase +extern __typeof (FcStrStr) IA__FcStrStr FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrStr IA__FcStrStr +extern __typeof (FcUtf8ToUcs4) IA__FcUtf8ToUcs4 FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcUtf8ToUcs4 IA__FcUtf8ToUcs4 +extern __typeof (FcUtf8Len) IA__FcUtf8Len FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcUtf8Len IA__FcUtf8Len +extern __typeof (FcUcs4ToUtf8) IA__FcUcs4ToUtf8 FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcUcs4ToUtf8 IA__FcUcs4ToUtf8 +extern __typeof (FcUtf16ToUcs4) IA__FcUtf16ToUcs4 FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcUtf16ToUcs4 IA__FcUtf16ToUcs4 +extern __typeof (FcUtf16Len) IA__FcUtf16Len FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcUtf16Len IA__FcUtf16Len +extern __typeof (FcStrBuildFilename) IA__FcStrBuildFilename FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrBuildFilename IA__FcStrBuildFilename +extern __typeof (FcStrDirname) IA__FcStrDirname FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrDirname IA__FcStrDirname +extern __typeof (FcStrBasename) IA__FcStrBasename FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrBasename IA__FcStrBasename +extern __typeof (FcStrSetCreate) IA__FcStrSetCreate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrSetCreate IA__FcStrSetCreate +extern __typeof (FcStrSetMember) IA__FcStrSetMember FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrSetMember IA__FcStrSetMember +extern __typeof (FcStrSetEqual) IA__FcStrSetEqual FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrSetEqual IA__FcStrSetEqual +extern __typeof (FcStrSetAdd) IA__FcStrSetAdd FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrSetAdd IA__FcStrSetAdd +extern __typeof (FcStrSetAddFilename) IA__FcStrSetAddFilename FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrSetAddFilename IA__FcStrSetAddFilename +extern __typeof (FcStrSetDel) IA__FcStrSetDel FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrSetDel IA__FcStrSetDel +extern __typeof (FcStrSetDestroy) IA__FcStrSetDestroy FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrSetDestroy IA__FcStrSetDestroy +extern __typeof (FcStrListCreate) IA__FcStrListCreate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrListCreate IA__FcStrListCreate +extern __typeof (FcStrListFirst) IA__FcStrListFirst FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrListFirst IA__FcStrListFirst +extern __typeof (FcStrListNext) IA__FcStrListNext FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrListNext IA__FcStrListNext +extern __typeof (FcStrListDone) IA__FcStrListDone FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcStrListDone IA__FcStrListDone +extern __typeof (FcConfigParseAndLoad) IA__FcConfigParseAndLoad FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigParseAndLoad IA__FcConfigParseAndLoad +extern __typeof (FcConfigParseAndLoadFromMemory) IA__FcConfigParseAndLoadFromMemory FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigParseAndLoadFromMemory IA__FcConfigParseAndLoadFromMemory +extern __typeof (FcConfigFileGenerate) IA__FcConfigFileGenerate FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigFileGenerate IA__FcConfigFileGenerate +extern __typeof (FcConfigGetRescanInverval) IA__FcConfigGetRescanInverval FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigGetRescanInverval IA__FcConfigGetRescanInverval +extern __typeof (FcConfigSetRescanInverval) IA__FcConfigSetRescanInverval FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcConfigSetRescanInverval IA__FcConfigSetRescanInverval diff --git a/pkg/fontconfig/override/src/fcaliastail.h b/pkg/fontconfig/override/src/fcaliastail.h new file mode 100644 index 000000000..459029301 --- /dev/null +++ b/pkg/fontconfig/override/src/fcaliastail.h @@ -0,0 +1,528 @@ +#if HAVE_GNUC_ATTRIBUTE +#ifdef __fccfg__ +# undef FcBlanksCreate +extern __typeof (FcBlanksCreate) FcBlanksCreate __attribute((alias("IA__FcBlanksCreate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcBlanksDestroy +extern __typeof (FcBlanksDestroy) FcBlanksDestroy __attribute((alias("IA__FcBlanksDestroy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcBlanksAdd +extern __typeof (FcBlanksAdd) FcBlanksAdd __attribute((alias("IA__FcBlanksAdd"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcBlanksIsMember +extern __typeof (FcBlanksIsMember) FcBlanksIsMember __attribute((alias("IA__FcBlanksIsMember"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fccfg__ */ +#ifdef __fccache__ +# undef FcCacheCopySet +extern __typeof (FcCacheCopySet) FcCacheCopySet __attribute((alias("IA__FcCacheCopySet"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCacheNumSubdir +extern __typeof (FcCacheNumSubdir) FcCacheNumSubdir __attribute((alias("IA__FcCacheNumSubdir"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCacheNumFont +extern __typeof (FcCacheNumFont) FcCacheNumFont __attribute((alias("IA__FcCacheNumFont"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcDirCacheUnlink +extern __typeof (FcDirCacheUnlink) FcDirCacheUnlink __attribute((alias("IA__FcDirCacheUnlink"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcDirCacheValid +extern __typeof (FcDirCacheValid) FcDirCacheValid __attribute((alias("IA__FcDirCacheValid"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcDirCacheClean +extern __typeof (FcDirCacheClean) FcDirCacheClean __attribute((alias("IA__FcDirCacheClean"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCacheCreateTagFile +extern __typeof (FcCacheCreateTagFile) FcCacheCreateTagFile __attribute((alias("IA__FcCacheCreateTagFile"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcDirCacheCreateUUID +extern __typeof (FcDirCacheCreateUUID) FcDirCacheCreateUUID __attribute((alias("IA__FcDirCacheCreateUUID"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcDirCacheDeleteUUID +extern __typeof (FcDirCacheDeleteUUID) FcDirCacheDeleteUUID __attribute((alias("IA__FcDirCacheDeleteUUID"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fccache__ */ +#ifdef __fccfg__ +# undef FcConfigHome +extern __typeof (FcConfigHome) FcConfigHome __attribute((alias("IA__FcConfigHome"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigEnableHome +extern __typeof (FcConfigEnableHome) FcConfigEnableHome __attribute((alias("IA__FcConfigEnableHome"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigGetFilename +extern __typeof (FcConfigGetFilename) FcConfigGetFilename __attribute((alias("IA__FcConfigGetFilename"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigFilename +extern __typeof (FcConfigFilename) FcConfigFilename __attribute((alias("IA__FcConfigFilename"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigCreate +extern __typeof (FcConfigCreate) FcConfigCreate __attribute((alias("IA__FcConfigCreate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigReference +extern __typeof (FcConfigReference) FcConfigReference __attribute((alias("IA__FcConfigReference"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigDestroy +extern __typeof (FcConfigDestroy) FcConfigDestroy __attribute((alias("IA__FcConfigDestroy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigSetCurrent +extern __typeof (FcConfigSetCurrent) FcConfigSetCurrent __attribute((alias("IA__FcConfigSetCurrent"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigGetCurrent +extern __typeof (FcConfigGetCurrent) FcConfigGetCurrent __attribute((alias("IA__FcConfigGetCurrent"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigUptoDate +extern __typeof (FcConfigUptoDate) FcConfigUptoDate __attribute((alias("IA__FcConfigUptoDate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigBuildFonts +extern __typeof (FcConfigBuildFonts) FcConfigBuildFonts __attribute((alias("IA__FcConfigBuildFonts"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigGetFontDirs +extern __typeof (FcConfigGetFontDirs) FcConfigGetFontDirs __attribute((alias("IA__FcConfigGetFontDirs"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigGetConfigDirs +extern __typeof (FcConfigGetConfigDirs) FcConfigGetConfigDirs __attribute((alias("IA__FcConfigGetConfigDirs"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigGetConfigFiles +extern __typeof (FcConfigGetConfigFiles) FcConfigGetConfigFiles __attribute((alias("IA__FcConfigGetConfigFiles"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigGetCache +extern __typeof (FcConfigGetCache) FcConfigGetCache __attribute((alias("IA__FcConfigGetCache"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigGetBlanks +extern __typeof (FcConfigGetBlanks) FcConfigGetBlanks __attribute((alias("IA__FcConfigGetBlanks"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigGetCacheDirs +extern __typeof (FcConfigGetCacheDirs) FcConfigGetCacheDirs __attribute((alias("IA__FcConfigGetCacheDirs"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigGetRescanInterval +extern __typeof (FcConfigGetRescanInterval) FcConfigGetRescanInterval __attribute((alias("IA__FcConfigGetRescanInterval"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigSetRescanInterval +extern __typeof (FcConfigSetRescanInterval) FcConfigSetRescanInterval __attribute((alias("IA__FcConfigSetRescanInterval"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigGetFonts +extern __typeof (FcConfigGetFonts) FcConfigGetFonts __attribute((alias("IA__FcConfigGetFonts"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigAcceptFont +extern __typeof (FcConfigAcceptFont) FcConfigAcceptFont __attribute((alias("IA__FcConfigAcceptFont"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigAcceptFilename +extern __typeof (FcConfigAcceptFilename) FcConfigAcceptFilename __attribute((alias("IA__FcConfigAcceptFilename"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigAcceptFilter +extern __typeof (FcConfigAcceptFilter) FcConfigAcceptFilter __attribute((alias("IA__FcConfigAcceptFilter"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigAppFontAddFile +extern __typeof (FcConfigAppFontAddFile) FcConfigAppFontAddFile __attribute((alias("IA__FcConfigAppFontAddFile"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigAppFontAddDir +extern __typeof (FcConfigAppFontAddDir) FcConfigAppFontAddDir __attribute((alias("IA__FcConfigAppFontAddDir"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigAppFontClear +extern __typeof (FcConfigAppFontClear) FcConfigAppFontClear __attribute((alias("IA__FcConfigAppFontClear"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigPreferAppFont +extern __typeof (FcConfigPreferAppFont) FcConfigPreferAppFont __attribute((alias("IA__FcConfigPreferAppFont"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigSetWarningFlags +extern __typeof (FcConfigSetWarningFlags) FcConfigSetWarningFlags __attribute((alias("IA__FcConfigSetWarningFlags"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigGetWarningFlags +extern __typeof (FcConfigGetWarningFlags) FcConfigGetWarningFlags __attribute((alias("IA__FcConfigGetWarningFlags"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigSubstituteWithPat +extern __typeof (FcConfigSubstituteWithPat) FcConfigSubstituteWithPat __attribute((alias("IA__FcConfigSubstituteWithPat"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigSubstitute +extern __typeof (FcConfigSubstitute) FcConfigSubstitute __attribute((alias("IA__FcConfigSubstitute"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigGetSysRoot +extern __typeof (FcConfigGetSysRoot) FcConfigGetSysRoot __attribute((alias("IA__FcConfigGetSysRoot"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigSetSysRoot +extern __typeof (FcConfigSetSysRoot) FcConfigSetSysRoot __attribute((alias("IA__FcConfigSetSysRoot"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigSetFontSetFilter +extern __typeof (FcConfigSetFontSetFilter) FcConfigSetFontSetFilter __attribute((alias("IA__FcConfigSetFontSetFilter"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigFileInfoIterInit +extern __typeof (FcConfigFileInfoIterInit) FcConfigFileInfoIterInit __attribute((alias("IA__FcConfigFileInfoIterInit"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigFileInfoIterNext +extern __typeof (FcConfigFileInfoIterNext) FcConfigFileInfoIterNext __attribute((alias("IA__FcConfigFileInfoIterNext"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigFileInfoIterGet +extern __typeof (FcConfigFileInfoIterGet) FcConfigFileInfoIterGet __attribute((alias("IA__FcConfigFileInfoIterGet"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fccfg__ */ +#ifdef __fccharset__ +# undef FcCharSetCreate +extern __typeof (FcCharSetCreate) FcCharSetCreate __attribute((alias("IA__FcCharSetCreate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetNew +extern __typeof (FcCharSetNew) FcCharSetNew __attribute((alias("IA__FcCharSetNew"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetDestroy +extern __typeof (FcCharSetDestroy) FcCharSetDestroy __attribute((alias("IA__FcCharSetDestroy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetAddChar +extern __typeof (FcCharSetAddChar) FcCharSetAddChar __attribute((alias("IA__FcCharSetAddChar"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetDelChar +extern __typeof (FcCharSetDelChar) FcCharSetDelChar __attribute((alias("IA__FcCharSetDelChar"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetCopy +extern __typeof (FcCharSetCopy) FcCharSetCopy __attribute((alias("IA__FcCharSetCopy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetEqual +extern __typeof (FcCharSetEqual) FcCharSetEqual __attribute((alias("IA__FcCharSetEqual"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetIntersect +extern __typeof (FcCharSetIntersect) FcCharSetIntersect __attribute((alias("IA__FcCharSetIntersect"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetUnion +extern __typeof (FcCharSetUnion) FcCharSetUnion __attribute((alias("IA__FcCharSetUnion"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetSubtract +extern __typeof (FcCharSetSubtract) FcCharSetSubtract __attribute((alias("IA__FcCharSetSubtract"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetMerge +extern __typeof (FcCharSetMerge) FcCharSetMerge __attribute((alias("IA__FcCharSetMerge"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetHasChar +extern __typeof (FcCharSetHasChar) FcCharSetHasChar __attribute((alias("IA__FcCharSetHasChar"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetCount +extern __typeof (FcCharSetCount) FcCharSetCount __attribute((alias("IA__FcCharSetCount"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetIntersectCount +extern __typeof (FcCharSetIntersectCount) FcCharSetIntersectCount __attribute((alias("IA__FcCharSetIntersectCount"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetSubtractCount +extern __typeof (FcCharSetSubtractCount) FcCharSetSubtractCount __attribute((alias("IA__FcCharSetSubtractCount"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetIsSubset +extern __typeof (FcCharSetIsSubset) FcCharSetIsSubset __attribute((alias("IA__FcCharSetIsSubset"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetFirstPage +extern __typeof (FcCharSetFirstPage) FcCharSetFirstPage __attribute((alias("IA__FcCharSetFirstPage"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetNextPage +extern __typeof (FcCharSetNextPage) FcCharSetNextPage __attribute((alias("IA__FcCharSetNextPage"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcCharSetCoverage +extern __typeof (FcCharSetCoverage) FcCharSetCoverage __attribute((alias("IA__FcCharSetCoverage"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fccharset__ */ +#ifdef __fcdbg__ +# undef FcValuePrint +extern __typeof (FcValuePrint) FcValuePrint __attribute((alias("IA__FcValuePrint"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternPrint +extern __typeof (FcPatternPrint) FcPatternPrint __attribute((alias("IA__FcPatternPrint"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFontSetPrint +extern __typeof (FcFontSetPrint) FcFontSetPrint __attribute((alias("IA__FcFontSetPrint"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcdbg__ */ +#ifdef __fcdefault__ +# undef FcConfigGetDefaultLangs +extern __typeof (FcConfigGetDefaultLangs) FcConfigGetDefaultLangs __attribute((alias("IA__FcConfigGetDefaultLangs"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcGetDefaultLangs +extern __typeof (FcGetDefaultLangs) FcGetDefaultLangs __attribute((alias("IA__FcGetDefaultLangs"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigSetDefaultSubstitute +extern __typeof (FcConfigSetDefaultSubstitute) FcConfigSetDefaultSubstitute __attribute((alias("IA__FcConfigSetDefaultSubstitute"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcDefaultSubstitute +extern __typeof (FcDefaultSubstitute) FcDefaultSubstitute __attribute((alias("IA__FcDefaultSubstitute"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcdefault__ */ +#ifdef __fcdir__ +# undef FcFileIsDir +extern __typeof (FcFileIsDir) FcFileIsDir __attribute((alias("IA__FcFileIsDir"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFileScan +extern __typeof (FcFileScan) FcFileScan __attribute((alias("IA__FcFileScan"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcDirScan +extern __typeof (FcDirScan) FcDirScan __attribute((alias("IA__FcDirScan"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcDirSave +extern __typeof (FcDirSave) FcDirSave __attribute((alias("IA__FcDirSave"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcdir__ */ +#ifdef __fccache__ +# undef FcDirCacheLoad +extern __typeof (FcDirCacheLoad) FcDirCacheLoad __attribute((alias("IA__FcDirCacheLoad"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fccache__ */ +#ifdef __fcdir__ +# undef FcDirCacheRescan +extern __typeof (FcDirCacheRescan) FcDirCacheRescan __attribute((alias("IA__FcDirCacheRescan"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcDirCacheRead +extern __typeof (FcDirCacheRead) FcDirCacheRead __attribute((alias("IA__FcDirCacheRead"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcdir__ */ +#ifdef __fccache__ +# undef FcDirCacheLoadFile +extern __typeof (FcDirCacheLoadFile) FcDirCacheLoadFile __attribute((alias("IA__FcDirCacheLoadFile"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcDirCacheUnload +extern __typeof (FcDirCacheUnload) FcDirCacheUnload __attribute((alias("IA__FcDirCacheUnload"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fccache__ */ +#ifdef __fcfs__ +# undef FcFontSetCreate +extern __typeof (FcFontSetCreate) FcFontSetCreate __attribute((alias("IA__FcFontSetCreate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFontSetDestroy +extern __typeof (FcFontSetDestroy) FcFontSetDestroy __attribute((alias("IA__FcFontSetDestroy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFontSetAdd +extern __typeof (FcFontSetAdd) FcFontSetAdd __attribute((alias("IA__FcFontSetAdd"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcfs__ */ +#ifdef __fcinit__ +# undef FcInitLoadConfig +extern __typeof (FcInitLoadConfig) FcInitLoadConfig __attribute((alias("IA__FcInitLoadConfig"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcInitLoadConfigAndFonts +extern __typeof (FcInitLoadConfigAndFonts) FcInitLoadConfigAndFonts __attribute((alias("IA__FcInitLoadConfigAndFonts"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcInit +extern __typeof (FcInit) FcInit __attribute((alias("IA__FcInit"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFini +extern __typeof (FcFini) FcFini __attribute((alias("IA__FcFini"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcGetVersion +extern __typeof (FcGetVersion) FcGetVersion __attribute((alias("IA__FcGetVersion"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcInitReinitialize +extern __typeof (FcInitReinitialize) FcInitReinitialize __attribute((alias("IA__FcInitReinitialize"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcInitBringUptoDate +extern __typeof (FcInitBringUptoDate) FcInitBringUptoDate __attribute((alias("IA__FcInitBringUptoDate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcinit__ */ +#ifdef __fclang__ +# undef FcGetLangs +extern __typeof (FcGetLangs) FcGetLangs __attribute((alias("IA__FcGetLangs"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangNormalize +extern __typeof (FcLangNormalize) FcLangNormalize __attribute((alias("IA__FcLangNormalize"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangGetCharSet +extern __typeof (FcLangGetCharSet) FcLangGetCharSet __attribute((alias("IA__FcLangGetCharSet"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangSetCreate +extern __typeof (FcLangSetCreate) FcLangSetCreate __attribute((alias("IA__FcLangSetCreate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangSetDestroy +extern __typeof (FcLangSetDestroy) FcLangSetDestroy __attribute((alias("IA__FcLangSetDestroy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangSetCopy +extern __typeof (FcLangSetCopy) FcLangSetCopy __attribute((alias("IA__FcLangSetCopy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangSetAdd +extern __typeof (FcLangSetAdd) FcLangSetAdd __attribute((alias("IA__FcLangSetAdd"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangSetDel +extern __typeof (FcLangSetDel) FcLangSetDel __attribute((alias("IA__FcLangSetDel"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangSetHasLang +extern __typeof (FcLangSetHasLang) FcLangSetHasLang __attribute((alias("IA__FcLangSetHasLang"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangSetCompare +extern __typeof (FcLangSetCompare) FcLangSetCompare __attribute((alias("IA__FcLangSetCompare"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangSetContains +extern __typeof (FcLangSetContains) FcLangSetContains __attribute((alias("IA__FcLangSetContains"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangSetEqual +extern __typeof (FcLangSetEqual) FcLangSetEqual __attribute((alias("IA__FcLangSetEqual"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangSetHash +extern __typeof (FcLangSetHash) FcLangSetHash __attribute((alias("IA__FcLangSetHash"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangSetGetLangs +extern __typeof (FcLangSetGetLangs) FcLangSetGetLangs __attribute((alias("IA__FcLangSetGetLangs"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangSetUnion +extern __typeof (FcLangSetUnion) FcLangSetUnion __attribute((alias("IA__FcLangSetUnion"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcLangSetSubtract +extern __typeof (FcLangSetSubtract) FcLangSetSubtract __attribute((alias("IA__FcLangSetSubtract"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fclang__ */ +#ifdef __fclist__ +# undef FcObjectSetCreate +extern __typeof (FcObjectSetCreate) FcObjectSetCreate __attribute((alias("IA__FcObjectSetCreate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcObjectSetAdd +extern __typeof (FcObjectSetAdd) FcObjectSetAdd __attribute((alias("IA__FcObjectSetAdd"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcObjectSetDestroy +extern __typeof (FcObjectSetDestroy) FcObjectSetDestroy __attribute((alias("IA__FcObjectSetDestroy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcObjectSetVaBuild +extern __typeof (FcObjectSetVaBuild) FcObjectSetVaBuild __attribute((alias("IA__FcObjectSetVaBuild"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcObjectSetBuild +extern __typeof (FcObjectSetBuild) FcObjectSetBuild __attribute((alias("IA__FcObjectSetBuild"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFontSetList +extern __typeof (FcFontSetList) FcFontSetList __attribute((alias("IA__FcFontSetList"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFontList +extern __typeof (FcFontList) FcFontList __attribute((alias("IA__FcFontList"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fclist__ */ +#ifdef __fcatomic__ +# undef FcAtomicCreate +extern __typeof (FcAtomicCreate) FcAtomicCreate __attribute((alias("IA__FcAtomicCreate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcAtomicLock +extern __typeof (FcAtomicLock) FcAtomicLock __attribute((alias("IA__FcAtomicLock"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcAtomicNewFile +extern __typeof (FcAtomicNewFile) FcAtomicNewFile __attribute((alias("IA__FcAtomicNewFile"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcAtomicOrigFile +extern __typeof (FcAtomicOrigFile) FcAtomicOrigFile __attribute((alias("IA__FcAtomicOrigFile"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcAtomicReplaceOrig +extern __typeof (FcAtomicReplaceOrig) FcAtomicReplaceOrig __attribute((alias("IA__FcAtomicReplaceOrig"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcAtomicDeleteNew +extern __typeof (FcAtomicDeleteNew) FcAtomicDeleteNew __attribute((alias("IA__FcAtomicDeleteNew"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcAtomicUnlock +extern __typeof (FcAtomicUnlock) FcAtomicUnlock __attribute((alias("IA__FcAtomicUnlock"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcAtomicDestroy +extern __typeof (FcAtomicDestroy) FcAtomicDestroy __attribute((alias("IA__FcAtomicDestroy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcatomic__ */ +#ifdef __fcmatch__ +# undef FcFontSetMatch +extern __typeof (FcFontSetMatch) FcFontSetMatch __attribute((alias("IA__FcFontSetMatch"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFontMatch +extern __typeof (FcFontMatch) FcFontMatch __attribute((alias("IA__FcFontMatch"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFontRenderPrepare +extern __typeof (FcFontRenderPrepare) FcFontRenderPrepare __attribute((alias("IA__FcFontRenderPrepare"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFontSetSort +extern __typeof (FcFontSetSort) FcFontSetSort __attribute((alias("IA__FcFontSetSort"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFontSort +extern __typeof (FcFontSort) FcFontSort __attribute((alias("IA__FcFontSort"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFontSetSortDestroy +extern __typeof (FcFontSetSortDestroy) FcFontSetSortDestroy __attribute((alias("IA__FcFontSetSortDestroy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcmatch__ */ +#ifdef __fcmatrix__ +# undef FcMatrixCopy +extern __typeof (FcMatrixCopy) FcMatrixCopy __attribute((alias("IA__FcMatrixCopy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcMatrixEqual +extern __typeof (FcMatrixEqual) FcMatrixEqual __attribute((alias("IA__FcMatrixEqual"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcMatrixMultiply +extern __typeof (FcMatrixMultiply) FcMatrixMultiply __attribute((alias("IA__FcMatrixMultiply"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcMatrixRotate +extern __typeof (FcMatrixRotate) FcMatrixRotate __attribute((alias("IA__FcMatrixRotate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcMatrixScale +extern __typeof (FcMatrixScale) FcMatrixScale __attribute((alias("IA__FcMatrixScale"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcMatrixShear +extern __typeof (FcMatrixShear) FcMatrixShear __attribute((alias("IA__FcMatrixShear"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcmatrix__ */ +#ifdef __fcname__ +# undef FcNameRegisterObjectTypes +extern __typeof (FcNameRegisterObjectTypes) FcNameRegisterObjectTypes __attribute((alias("IA__FcNameRegisterObjectTypes"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcNameUnregisterObjectTypes +extern __typeof (FcNameUnregisterObjectTypes) FcNameUnregisterObjectTypes __attribute((alias("IA__FcNameUnregisterObjectTypes"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcNameGetObjectType +extern __typeof (FcNameGetObjectType) FcNameGetObjectType __attribute((alias("IA__FcNameGetObjectType"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcNameRegisterConstants +extern __typeof (FcNameRegisterConstants) FcNameRegisterConstants __attribute((alias("IA__FcNameRegisterConstants"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcNameUnregisterConstants +extern __typeof (FcNameUnregisterConstants) FcNameUnregisterConstants __attribute((alias("IA__FcNameUnregisterConstants"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcNameGetConstant +extern __typeof (FcNameGetConstant) FcNameGetConstant __attribute((alias("IA__FcNameGetConstant"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcNameGetConstantFor +extern __typeof (FcNameGetConstantFor) FcNameGetConstantFor __attribute((alias("IA__FcNameGetConstantFor"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcNameConstant +extern __typeof (FcNameConstant) FcNameConstant __attribute((alias("IA__FcNameConstant"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcNameGetConstantNameFrom +extern __typeof (FcNameGetConstantNameFrom) FcNameGetConstantNameFrom __attribute((alias("IA__FcNameGetConstantNameFrom"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcNameParse +extern __typeof (FcNameParse) FcNameParse __attribute((alias("IA__FcNameParse"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcNameUnparse +extern __typeof (FcNameUnparse) FcNameUnparse __attribute((alias("IA__FcNameUnparse"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcname__ */ +#ifdef __fcpat__ +# undef FcPatternCreate +extern __typeof (FcPatternCreate) FcPatternCreate __attribute((alias("IA__FcPatternCreate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternDuplicate +extern __typeof (FcPatternDuplicate) FcPatternDuplicate __attribute((alias("IA__FcPatternDuplicate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternReference +extern __typeof (FcPatternReference) FcPatternReference __attribute((alias("IA__FcPatternReference"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternFilter +extern __typeof (FcPatternFilter) FcPatternFilter __attribute((alias("IA__FcPatternFilter"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcValueDestroy +extern __typeof (FcValueDestroy) FcValueDestroy __attribute((alias("IA__FcValueDestroy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcValueEqual +extern __typeof (FcValueEqual) FcValueEqual __attribute((alias("IA__FcValueEqual"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcValueSave +extern __typeof (FcValueSave) FcValueSave __attribute((alias("IA__FcValueSave"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternDestroy +extern __typeof (FcPatternDestroy) FcPatternDestroy __attribute((alias("IA__FcPatternDestroy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternObjectCount +extern __typeof (FcPatternObjectCount) FcPatternObjectCount __attribute((alias("IA__FcPatternObjectCount"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternEqual +extern __typeof (FcPatternEqual) FcPatternEqual __attribute((alias("IA__FcPatternEqual"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternEqualSubset +extern __typeof (FcPatternEqualSubset) FcPatternEqualSubset __attribute((alias("IA__FcPatternEqualSubset"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternHash +extern __typeof (FcPatternHash) FcPatternHash __attribute((alias("IA__FcPatternHash"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternAdd +extern __typeof (FcPatternAdd) FcPatternAdd __attribute((alias("IA__FcPatternAdd"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternAddWeak +extern __typeof (FcPatternAddWeak) FcPatternAddWeak __attribute((alias("IA__FcPatternAddWeak"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternGet +extern __typeof (FcPatternGet) FcPatternGet __attribute((alias("IA__FcPatternGet"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternGetWithBinding +extern __typeof (FcPatternGetWithBinding) FcPatternGetWithBinding __attribute((alias("IA__FcPatternGetWithBinding"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternDel +extern __typeof (FcPatternDel) FcPatternDel __attribute((alias("IA__FcPatternDel"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternRemove +extern __typeof (FcPatternRemove) FcPatternRemove __attribute((alias("IA__FcPatternRemove"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternAddInteger +extern __typeof (FcPatternAddInteger) FcPatternAddInteger __attribute((alias("IA__FcPatternAddInteger"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternAddDouble +extern __typeof (FcPatternAddDouble) FcPatternAddDouble __attribute((alias("IA__FcPatternAddDouble"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternAddString +extern __typeof (FcPatternAddString) FcPatternAddString __attribute((alias("IA__FcPatternAddString"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternAddMatrix +extern __typeof (FcPatternAddMatrix) FcPatternAddMatrix __attribute((alias("IA__FcPatternAddMatrix"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternAddCharSet +extern __typeof (FcPatternAddCharSet) FcPatternAddCharSet __attribute((alias("IA__FcPatternAddCharSet"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternAddBool +extern __typeof (FcPatternAddBool) FcPatternAddBool __attribute((alias("IA__FcPatternAddBool"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternAddLangSet +extern __typeof (FcPatternAddLangSet) FcPatternAddLangSet __attribute((alias("IA__FcPatternAddLangSet"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternAddRange +extern __typeof (FcPatternAddRange) FcPatternAddRange __attribute((alias("IA__FcPatternAddRange"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternGetInteger +extern __typeof (FcPatternGetInteger) FcPatternGetInteger __attribute((alias("IA__FcPatternGetInteger"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternGetDouble +extern __typeof (FcPatternGetDouble) FcPatternGetDouble __attribute((alias("IA__FcPatternGetDouble"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternGetString +extern __typeof (FcPatternGetString) FcPatternGetString __attribute((alias("IA__FcPatternGetString"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternGetMatrix +extern __typeof (FcPatternGetMatrix) FcPatternGetMatrix __attribute((alias("IA__FcPatternGetMatrix"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternGetCharSet +extern __typeof (FcPatternGetCharSet) FcPatternGetCharSet __attribute((alias("IA__FcPatternGetCharSet"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternGetBool +extern __typeof (FcPatternGetBool) FcPatternGetBool __attribute((alias("IA__FcPatternGetBool"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternGetLangSet +extern __typeof (FcPatternGetLangSet) FcPatternGetLangSet __attribute((alias("IA__FcPatternGetLangSet"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternGetRange +extern __typeof (FcPatternGetRange) FcPatternGetRange __attribute((alias("IA__FcPatternGetRange"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternVaBuild +extern __typeof (FcPatternVaBuild) FcPatternVaBuild __attribute((alias("IA__FcPatternVaBuild"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternBuild +extern __typeof (FcPatternBuild) FcPatternBuild __attribute((alias("IA__FcPatternBuild"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcpat__ */ +#ifdef __fcformat__ +# undef FcPatternFormat +extern __typeof (FcPatternFormat) FcPatternFormat __attribute((alias("IA__FcPatternFormat"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcformat__ */ +#ifdef __fcrange__ +# undef FcRangeCreateDouble +extern __typeof (FcRangeCreateDouble) FcRangeCreateDouble __attribute((alias("IA__FcRangeCreateDouble"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcRangeCreateInteger +extern __typeof (FcRangeCreateInteger) FcRangeCreateInteger __attribute((alias("IA__FcRangeCreateInteger"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcRangeDestroy +extern __typeof (FcRangeDestroy) FcRangeDestroy __attribute((alias("IA__FcRangeDestroy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcRangeCopy +extern __typeof (FcRangeCopy) FcRangeCopy __attribute((alias("IA__FcRangeCopy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcRangeGetDouble +extern __typeof (FcRangeGetDouble) FcRangeGetDouble __attribute((alias("IA__FcRangeGetDouble"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcrange__ */ +#ifdef __fcpat__ +# undef FcPatternIterStart +extern __typeof (FcPatternIterStart) FcPatternIterStart __attribute((alias("IA__FcPatternIterStart"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternIterNext +extern __typeof (FcPatternIterNext) FcPatternIterNext __attribute((alias("IA__FcPatternIterNext"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternIterEqual +extern __typeof (FcPatternIterEqual) FcPatternIterEqual __attribute((alias("IA__FcPatternIterEqual"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternFindIter +extern __typeof (FcPatternFindIter) FcPatternFindIter __attribute((alias("IA__FcPatternFindIter"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternIterIsValid +extern __typeof (FcPatternIterIsValid) FcPatternIterIsValid __attribute((alias("IA__FcPatternIterIsValid"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternIterGetObject +extern __typeof (FcPatternIterGetObject) FcPatternIterGetObject __attribute((alias("IA__FcPatternIterGetObject"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternIterValueCount +extern __typeof (FcPatternIterValueCount) FcPatternIterValueCount __attribute((alias("IA__FcPatternIterValueCount"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternIterGetValue +extern __typeof (FcPatternIterGetValue) FcPatternIterGetValue __attribute((alias("IA__FcPatternIterGetValue"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcpat__ */ +#ifdef __fcweight__ +# undef FcWeightFromOpenType +extern __typeof (FcWeightFromOpenType) FcWeightFromOpenType __attribute((alias("IA__FcWeightFromOpenType"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcWeightFromOpenTypeDouble +extern __typeof (FcWeightFromOpenTypeDouble) FcWeightFromOpenTypeDouble __attribute((alias("IA__FcWeightFromOpenTypeDouble"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcWeightToOpenType +extern __typeof (FcWeightToOpenType) FcWeightToOpenType __attribute((alias("IA__FcWeightToOpenType"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcWeightToOpenTypeDouble +extern __typeof (FcWeightToOpenTypeDouble) FcWeightToOpenTypeDouble __attribute((alias("IA__FcWeightToOpenTypeDouble"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcweight__ */ +#ifdef __fcstr__ +# undef FcStrCopy +extern __typeof (FcStrCopy) FcStrCopy __attribute((alias("IA__FcStrCopy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrCopyFilename +extern __typeof (FcStrCopyFilename) FcStrCopyFilename __attribute((alias("IA__FcStrCopyFilename"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrPlus +extern __typeof (FcStrPlus) FcStrPlus __attribute((alias("IA__FcStrPlus"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrFree +extern __typeof (FcStrFree) FcStrFree __attribute((alias("IA__FcStrFree"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrDowncase +extern __typeof (FcStrDowncase) FcStrDowncase __attribute((alias("IA__FcStrDowncase"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrCmpIgnoreCase +extern __typeof (FcStrCmpIgnoreCase) FcStrCmpIgnoreCase __attribute((alias("IA__FcStrCmpIgnoreCase"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrCmp +extern __typeof (FcStrCmp) FcStrCmp __attribute((alias("IA__FcStrCmp"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrStrIgnoreCase +extern __typeof (FcStrStrIgnoreCase) FcStrStrIgnoreCase __attribute((alias("IA__FcStrStrIgnoreCase"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrStr +extern __typeof (FcStrStr) FcStrStr __attribute((alias("IA__FcStrStr"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcUtf8ToUcs4 +extern __typeof (FcUtf8ToUcs4) FcUtf8ToUcs4 __attribute((alias("IA__FcUtf8ToUcs4"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcUtf8Len +extern __typeof (FcUtf8Len) FcUtf8Len __attribute((alias("IA__FcUtf8Len"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcUcs4ToUtf8 +extern __typeof (FcUcs4ToUtf8) FcUcs4ToUtf8 __attribute((alias("IA__FcUcs4ToUtf8"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcUtf16ToUcs4 +extern __typeof (FcUtf16ToUcs4) FcUtf16ToUcs4 __attribute((alias("IA__FcUtf16ToUcs4"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcUtf16Len +extern __typeof (FcUtf16Len) FcUtf16Len __attribute((alias("IA__FcUtf16Len"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrBuildFilename +extern __typeof (FcStrBuildFilename) FcStrBuildFilename __attribute((alias("IA__FcStrBuildFilename"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrDirname +extern __typeof (FcStrDirname) FcStrDirname __attribute((alias("IA__FcStrDirname"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrBasename +extern __typeof (FcStrBasename) FcStrBasename __attribute((alias("IA__FcStrBasename"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrSetCreate +extern __typeof (FcStrSetCreate) FcStrSetCreate __attribute((alias("IA__FcStrSetCreate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrSetMember +extern __typeof (FcStrSetMember) FcStrSetMember __attribute((alias("IA__FcStrSetMember"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrSetEqual +extern __typeof (FcStrSetEqual) FcStrSetEqual __attribute((alias("IA__FcStrSetEqual"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrSetAdd +extern __typeof (FcStrSetAdd) FcStrSetAdd __attribute((alias("IA__FcStrSetAdd"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrSetAddFilename +extern __typeof (FcStrSetAddFilename) FcStrSetAddFilename __attribute((alias("IA__FcStrSetAddFilename"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrSetDel +extern __typeof (FcStrSetDel) FcStrSetDel __attribute((alias("IA__FcStrSetDel"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrSetDestroy +extern __typeof (FcStrSetDestroy) FcStrSetDestroy __attribute((alias("IA__FcStrSetDestroy"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrListCreate +extern __typeof (FcStrListCreate) FcStrListCreate __attribute((alias("IA__FcStrListCreate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrListFirst +extern __typeof (FcStrListFirst) FcStrListFirst __attribute((alias("IA__FcStrListFirst"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrListNext +extern __typeof (FcStrListNext) FcStrListNext __attribute((alias("IA__FcStrListNext"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcStrListDone +extern __typeof (FcStrListDone) FcStrListDone __attribute((alias("IA__FcStrListDone"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcstr__ */ +#ifdef __fcxml__ +# undef FcConfigParseAndLoad +extern __typeof (FcConfigParseAndLoad) FcConfigParseAndLoad __attribute((alias("IA__FcConfigParseAndLoad"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigParseAndLoadFromMemory +extern __typeof (FcConfigParseAndLoadFromMemory) FcConfigParseAndLoadFromMemory __attribute((alias("IA__FcConfigParseAndLoadFromMemory"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcxml__ */ +#ifdef __fcconffile__ +# undef FcConfigFileGenerate +extern __typeof (FcConfigFileGenerate) FcConfigFileGenerate __attribute((alias("IA__FcConfigFileGenerate"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcconffile__ */ +#ifdef __fccfg__ +# undef FcConfigGetRescanInverval +extern __typeof (FcConfigGetRescanInverval) FcConfigGetRescanInverval __attribute((alias("IA__FcConfigGetRescanInverval"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcConfigSetRescanInverval +extern __typeof (FcConfigSetRescanInverval) FcConfigSetRescanInverval __attribute((alias("IA__FcConfigSetRescanInverval"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* */ +#endif /* HAVE_GNUC_ATTRIBUTE */ diff --git a/pkg/fontconfig/override/src/fcftalias.h b/pkg/fontconfig/override/src/fcftalias.h new file mode 100644 index 000000000..4af6a68d6 --- /dev/null +++ b/pkg/fontconfig/override/src/fcftalias.h @@ -0,0 +1,16 @@ +extern __typeof (FcFreeTypeCharIndex) IA__FcFreeTypeCharIndex FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFreeTypeCharIndex IA__FcFreeTypeCharIndex +extern __typeof (FcFreeTypeCharSetAndSpacing) IA__FcFreeTypeCharSetAndSpacing FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFreeTypeCharSetAndSpacing IA__FcFreeTypeCharSetAndSpacing +extern __typeof (FcFreeTypeCharSet) IA__FcFreeTypeCharSet FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFreeTypeCharSet IA__FcFreeTypeCharSet +extern __typeof (FcPatternGetFTFace) IA__FcPatternGetFTFace FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternGetFTFace IA__FcPatternGetFTFace +extern __typeof (FcPatternAddFTFace) IA__FcPatternAddFTFace FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcPatternAddFTFace IA__FcPatternAddFTFace +extern __typeof (FcFreeTypeQueryFace) IA__FcFreeTypeQueryFace FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFreeTypeQueryFace IA__FcFreeTypeQueryFace +extern __typeof (FcFreeTypeQuery) IA__FcFreeTypeQuery FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFreeTypeQuery IA__FcFreeTypeQuery +extern __typeof (FcFreeTypeQueryAll) IA__FcFreeTypeQueryAll FC_ATTRIBUTE_VISIBILITY_HIDDEN; +#define FcFreeTypeQueryAll IA__FcFreeTypeQueryAll diff --git a/pkg/fontconfig/override/src/fcftaliastail.h b/pkg/fontconfig/override/src/fcftaliastail.h new file mode 100644 index 000000000..299416edb --- /dev/null +++ b/pkg/fontconfig/override/src/fcftaliastail.h @@ -0,0 +1,24 @@ +#if HAVE_GNUC_ATTRIBUTE +#ifdef __fcfreetype__ +# undef FcFreeTypeCharIndex +extern __typeof (FcFreeTypeCharIndex) FcFreeTypeCharIndex __attribute((alias("IA__FcFreeTypeCharIndex"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFreeTypeCharSetAndSpacing +extern __typeof (FcFreeTypeCharSetAndSpacing) FcFreeTypeCharSetAndSpacing __attribute((alias("IA__FcFreeTypeCharSetAndSpacing"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFreeTypeCharSet +extern __typeof (FcFreeTypeCharSet) FcFreeTypeCharSet __attribute((alias("IA__FcFreeTypeCharSet"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcfreetype__ */ +#ifdef __fcpat__ +# undef FcPatternGetFTFace +extern __typeof (FcPatternGetFTFace) FcPatternGetFTFace __attribute((alias("IA__FcPatternGetFTFace"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcPatternAddFTFace +extern __typeof (FcPatternAddFTFace) FcPatternAddFTFace __attribute((alias("IA__FcPatternAddFTFace"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* __fcpat__ */ +#ifdef __fcfreetype__ +# undef FcFreeTypeQueryFace +extern __typeof (FcFreeTypeQueryFace) FcFreeTypeQueryFace __attribute((alias("IA__FcFreeTypeQueryFace"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFreeTypeQuery +extern __typeof (FcFreeTypeQuery) FcFreeTypeQuery __attribute((alias("IA__FcFreeTypeQuery"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +# undef FcFreeTypeQueryAll +extern __typeof (FcFreeTypeQueryAll) FcFreeTypeQueryAll __attribute((alias("IA__FcFreeTypeQueryAll"))) FC_ATTRIBUTE_VISIBILITY_EXPORT; +#endif /* */ +#endif /* HAVE_GNUC_ATTRIBUTE */ diff --git a/pkg/fontconfig/override/src/fcint.h b/pkg/fontconfig/override/src/fcint.h new file mode 100644 index 000000000..00f70533c --- /dev/null +++ b/pkg/fontconfig/override/src/fcint.h @@ -0,0 +1,1752 @@ +/* + * fontconfig/src/fcint.h + * + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of the author(s) not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. The authors make no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _FCINT_H_ +#define _FCINT_H_ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include "fcstdint.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef HAVE_UNISTD_H +# include +#endif +#include +#include + +#if ENABLE_FONTATIONS +# include +#endif + +#include +#include +#include +#include + +#ifdef HAVE_XLOCALE_H +#include +#endif + +#include "fcatomic.h" +#include "fcdeprecate.h" +#include "fcmutex.h" + +#ifndef FC_CONFIG_PATH +# define FC_CONFIG_PATH "fonts.conf" +#endif + +#ifdef _WIN32 +# define FC_LIKELY(expr) (expr) +# define FC_UNLIKELY(expr) (expr) +#else +# define FC_LIKELY(expr) (__builtin_expect (((expr) ? 1 : 0), 1)) +# define FC_UNLIKELY(expr) (__builtin_expect (((expr) ? 1 : 0), 0)) +#endif + +#ifdef _WIN32 +# include "fcwindows.h" +typedef UINT (WINAPI *pfnGetSystemWindowsDirectory) (LPSTR, UINT); +typedef HRESULT (WINAPI *pfnSHGetFolderPathA) (HWND, int, HANDLE, DWORD, LPSTR); +extern pfnGetSystemWindowsDirectory pGetSystemWindowsDirectory; +extern pfnSHGetFolderPathA pSHGetFolderPathA; +# define FC_SEARCH_PATH_SEPARATOR ';' +# define FC_DIR_SEPARATOR '\\' +# define FC_DIR_SEPARATOR_S "\\" +#else +# define FC_SEARCH_PATH_SEPARATOR ':' +# define FC_DIR_SEPARATOR '/' +# define FC_DIR_SEPARATOR_S "/" +#endif + +#ifdef PATH_MAX +# define FC_PATH_MAX PATH_MAX +#else +# define FC_PATH_MAX 128 +#endif + +#if __GNUC__ >= 4 +# define FC_UNUSED __attribute__ ((unused)) +#else +# define FC_UNUSED +#endif + +#ifndef FC_UINT64_FORMAT +# define FC_UINT64_FORMAT "llu" +#endif + +#define FC_DBG_MATCH 1 +#define FC_DBG_MATCHV 2 +#define FC_DBG_EDIT 4 +#define FC_DBG_FONTSET 8 +#define FC_DBG_CACHE 16 +#define FC_DBG_CACHEV 32 +#define FC_DBG_PARSE 64 +#define FC_DBG_SCAN 128 +#define FC_DBG_SCANV 256 +#define FC_DBG_CONFIG 1024 +#define FC_DBG_LANGSET 2048 +#define FC_DBG_MATCH2 4096 + +#define _FC_ASSERT_STATIC1(_line, _cond) typedef int _static_assert_on_line_##_line##_failed[(_cond) ? 1 : -1] FC_UNUSED +#define _FC_ASSERT_STATIC0(_line, _cond) _FC_ASSERT_STATIC1 (_line, (_cond)) +#define FC_ASSERT_STATIC(_cond) _FC_ASSERT_STATIC0 (__LINE__, (_cond)) + +#define FC_MIN(a, b) ((a) < (b) ? (a) : (b)) +#define FC_MAX(a, b) ((a) > (b) ? (a) : (b)) + +/* slim_internal.h */ +#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__) && !defined(__sun) && !defined(BINDGEN_IGNORE_VISIBILITY) +# define FcPrivate __attribute__ ((__visibility__ ("hidden"))) +# define HAVE_GNUC_ATTRIBUTE 1 +# include "fcalias.h" +#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550) +# define FcPrivate __hidden +#else /* not gcc >= 3.3 and not Sun Studio >= 8 */ +# define FcPrivate +#endif + +/* NLS */ +#ifdef ENABLE_NLS +# include +# define _(x) (dgettext (GETTEXT_PACKAGE, x)) +#else +/* dgettext macro must be defined after existing declarations */ +# include +# define dgettext(d, s) (s) +# define _(x) (x) +#endif + +#define N_(x) x + +FC_ASSERT_STATIC (sizeof (FcRef) == sizeof (int)); + +#define FcFree(s) (free ((FcChar8 *)(s))) + +/* + * Serialized data structures use only offsets instead of pointers + * A low bit of 1 indicates an offset. + */ + +/* Is the provided pointer actually an offset? */ +#define FcIsEncodedOffset(p) ((((uintptr_t)(p)) & 1) != 0) + +/* Encode offset in a pointer of type t */ +#define FcOffsetEncode(o, t) ((t *)(uintptr_t)((o) | 1)) + +/* Decode a pointer into an offset */ +#define FcOffsetDecode(p) (((uintptr_t)(p)) & ~1) + +/* Compute pointer offset */ +#define FcPtrToOffset(b, p) ((ptrdiff_t)((uintptr_t)(p) - (uintptr_t)(b))) + +/* Given base address, offset and type, return a pointer */ +#define FcOffsetToPtr(b, o, t) ((t *)((uintptr_t)(b) + (ptrdiff_t)(o))) + +/* Given base address, encoded offset and type, return a pointer */ +#define FcEncodedOffsetToPtr(b, p, t) FcOffsetToPtr (b, FcOffsetDecode (p), t) + +/* Given base address, pointer and type, return an encoded offset */ +#define FcPtrToEncodedOffset(b, p, t) FcOffsetEncode (FcPtrToOffset (b, p), t) + +/* Given a structure, offset member and type, return pointer */ +#define FcOffsetMember(s, m, t) FcOffsetToPtr (s, (s)->m, t) + +/* Given a structure, encoded offset member and type, return pointer to member */ +#define FcEncodedOffsetMember(s, m, t) FcOffsetToPtr (s, FcOffsetDecode ((s)->m), t) + +/* Given a structure, member and type, convert the member to a pointer */ +#define FcPointerMember(s, m, t) (FcIsEncodedOffset ((s)->m) ? FcEncodedOffsetMember (s, m, t) : (s)->m) + +/* + * Serialized values may hold strings, charsets and langsets as pointers, + * unfortunately FcValue is an exposed type so we can't just always use + * offsets + */ +#define FcValueString(v) FcPointerMember (v, u.s, FcChar8) +#define FcValueCharSet(v) FcPointerMember (v, u.c, const FcCharSet) +#define FcValueLangSet(v) FcPointerMember (v, u.l, const FcLangSet) +#define FcValueRange(v) FcPointerMember (v, u.r, const FcRange) + +typedef struct _FcValueList *FcValueListPtr; + +typedef struct _FcValueList { + struct _FcValueList *next; + FcValue value; + FcValueBinding binding; +} FcValueList; + +#define FcValueListNext(vl) FcPointerMember (vl, next, FcValueList) + +/* The 1024 is to leave some room for future added internal objects, such + * that caches from newer fontconfig can still be used with older fontconfig + * without getting confused. */ +#define FC_EXT_OBJ_INDEX 1024 +#define FC_OBJ_ID(_n_) ((_n_) & (~FC_EXT_OBJ_INDEX)) + +typedef struct _FcPatternElt *FcPatternEltPtr; + +/* + * Pattern elts are stuck in a structure connected to the pattern, + * so they get moved around when the pattern is resized. Hence, the + * values field must be a pointer/offset instead of just an offset + */ +typedef struct _FcPatternElt { + FcObject object; + FcValueList *values; +} FcPatternElt; + +#define FcPatternEltValues(pe) FcPointerMember (pe, values, FcValueList) + +struct _FcPattern { + int num; + int size; + intptr_t elts_offset; + FcRef ref; +}; + +#define FcPatternElts(p) FcOffsetMember (p, elts_offset, FcPatternElt) + +#define FcFontSetFonts(fs) FcPointerMember (fs, fonts, FcPattern *) + +#define FcFontSetFont(fs, i) (FcIsEncodedOffset ((fs)->fonts) ? FcEncodedOffsetToPtr (fs, \ + FcFontSetFonts (fs)[i], \ + FcPattern) \ + : fs->fonts[i]) + +typedef enum _FcOp { + FcOpInteger, + FcOpDouble, + FcOpString, + FcOpMatrix, + FcOpRange, + FcOpBool, + FcOpCharSet, + FcOpLangSet, + FcOpNil, + FcOpField, + FcOpConst, + FcOpAssign, + FcOpAssignReplace, + FcOpPrependFirst, + FcOpPrepend, + FcOpAppend, + FcOpAppendLast, + FcOpDelete, + FcOpDeleteAll, + FcOpQuest, + FcOpOr, + FcOpAnd, + FcOpEqual, + FcOpNotEqual, + FcOpContains, + FcOpListing, + FcOpNotContains, + FcOpLess, + FcOpLessEqual, + FcOpMore, + FcOpMoreEqual, + FcOpPlus, + FcOpMinus, + FcOpTimes, + FcOpDivide, + FcOpNot, + FcOpComma, + FcOpFloor, + FcOpCeil, + FcOpRound, + FcOpTrunc, + FcOpInvalid +} FcOp; + +typedef enum _FcOpFlags { + FcOpFlagIgnoreBlanks = 1U << 0 +} FcOpFlags; + +#define FC_OP_GET_OP(_x_) ((_x_) & 0xffff) +#define FC_OP_GET_FLAGS(_x_) (((_x_) & 0xffff0000) >> 16) +#define FC_OP(_x_, _f_) (FC_OP_GET_OP (_x_) | ((_f_) << 16)) + +typedef struct _FcExprMatrix { + struct _FcExpr *xx, *xy, *yx, *yy; +} FcExprMatrix; + +typedef struct _FcExprName { + FcObject object; + FcMatchKind kind; +} FcExprName; + +struct _FcRange { + double begin; + double end; +}; + +typedef struct _FcExpr { + FcOp op; + union { + int ival; + double dval; + const FcChar8 *sval; + FcExprMatrix *mexpr; + FcBool bval; + FcCharSet *cval; + FcLangSet *lval; + FcRange *rval; + + FcExprName name; + const FcChar8 *constant; + struct { + struct _FcExpr *left, *right; + } tree; + } u; +} FcExpr; + +typedef struct _FcExprPage FcExprPage; + +struct _FcExprPage { + FcExprPage *next_page; + FcExpr *next; + FcExpr exprs[(1024 - 2 /* two pointers */ - 2 /* malloc overhead */) * sizeof (void *) / sizeof (FcExpr)]; + FcExpr end[FLEXIBLE_ARRAY_MEMBER]; +}; + +typedef enum _FcQual { + FcQualAny, + FcQualAll, + FcQualFirst, + FcQualNotFirst +} FcQual; + +#define FcMatchDefault ((FcMatchKind) - 1) + +typedef struct _FcTest { + FcMatchKind kind; + FcQual qual; + FcObject object; + FcOp op; + FcExpr *expr; +} FcTest; + +typedef struct _FcEdit { + FcObject object; + FcOp op; + FcExpr *expr; + FcValueBinding binding; +} FcEdit; + +typedef struct _FcPtrList FcPtrList; +/* need to sync with FcConfigFileInfoIter at fontconfig.h */ +typedef struct _FcPtrListIter { + void *dummy1; + void *dummy2; + void *dummy3; +} FcPtrListIter; + +typedef enum _FcRuleType { + FcRuleUnknown, + FcRuleTest, + FcRuleEdit +} FcRuleType; + +typedef struct _FcRule { + struct _FcRule *next; + FcRuleType type; + union { + FcTest *test; + FcEdit *edit; + } u; +} FcRule; + +typedef struct _FcRuleSet { + FcRef ref; + FcChar8 *name; + FcChar8 *description; + FcChar8 *domain; + FcBool enabled; + FcPtrList *subst[FcMatchKindEnd]; +} FcRuleSet; + +typedef struct _FcCharLeaf { + FcChar32 map[256 / 32]; +} FcCharLeaf; + +struct _FcCharSet { + FcRef ref; /* reference count */ + int num; /* size of leaves and numbers arrays */ + intptr_t leaves_offset; + intptr_t numbers_offset; +}; + +#define FcCharSetLeaves(c) FcOffsetMember (c, leaves_offset, intptr_t) +#define FcCharSetLeaf(c, i) (FcOffsetToPtr (FcCharSetLeaves (c), \ + FcCharSetLeaves (c)[i], \ + FcCharLeaf)) +#define FcCharSetNumbers(c) FcOffsetMember (c, numbers_offset, FcChar16) + +#define FCSS_DEFAULT 0 /* default behavior */ +#define FCSS_ALLOW_DUPLICATES 1 /* allows for duplicate strings in the set */ +#define FCSS_GROW_BY_64 2 /* grows buffer by 64 elements instead of 1 */ + +#define FcStrSetHasControlBit(s, c) (s->control & c) +#define FcStrSetHasControlBits(s, c) ((c) == (s->control & (c))) + +struct _FcStrSet { + FcRef ref; /* reference count */ + int num; + int size; + FcChar8 **strs; + unsigned int control; /* control bits for set behavior */ +}; + +struct _FcStrList { + FcStrSet *set; + int n; +}; + +typedef struct _FcStrBuf { + FcChar8 *buf; + FcBool allocated; + FcBool failed; + int len; + int size; + FcChar8 buf_static[16 * sizeof (void *)]; +} FcStrBuf; + +typedef struct _FcHashTable FcHashTable; + +typedef FcChar32 (*FcHashFunc) (const FcChar8 *data); +typedef int (*FcCompareFunc) (const FcChar8 *v1, const FcChar8 *v2); +typedef FcBool (*FcCopyFunc) (const void *src, void **dest); + +struct _FcCache { + unsigned int magic; /* FC_CACHE_MAGIC_MMAP or FC_CACHE_ALLOC */ + int version; /* FC_CACHE_VERSION_NUMBER */ + intptr_t size; /* size of file */ + intptr_t dir; /* offset to dir name */ + intptr_t dirs; /* offset to subdirs */ + int dirs_count; /* number of subdir strings */ + int pad1; + intptr_t set; /* offset to font set */ + int checksum; /* checksum of directory state */ + int pad2; + int64_t checksum_nano; /* checksum of directory state */ + int64_t fc_version; /* fontconfig version */ +}; + +#undef FcCacheDir +#undef FcCacheSubdir +#define FcCacheDir(c) FcOffsetMember (c, dir, FcChar8) +#define FcCacheDirs(c) FcOffsetMember (c, dirs, intptr_t) +#define FcCacheSet(c) FcOffsetMember (c, set, FcFontSet) +#define FcCacheSubdir(c, i) FcOffsetToPtr (FcCacheDirs (c), \ + FcCacheDirs (c)[i], \ + FcChar8) + +/* + * Used while constructing a directory cache object + */ + +typedef union _FcAlign { + double d; + int i; + intptr_t ip; + FcBool b; + void *p; +} FcAlign; + +typedef struct _FcSerializeBucket { + const void *object; /* key */ + uintptr_t hash; /* hash of key */ + intptr_t offset; /* value */ +} FcSerializeBucket; + +typedef struct _FcCharSetFreezer FcCharSetFreezer; + +typedef struct _FcSerialize { + intptr_t size; + FcCharSetFreezer *cs_freezer; + void *linear; + FcSerializeBucket *buckets; + size_t buckets_count; + size_t buckets_used; + size_t buckets_used_max; +} FcSerialize; + +/* + * To map adobe glyph names to unicode values, a precomputed hash + * table is used + */ + +typedef struct _FcGlyphName { + FcChar32 ucs; /* unicode value */ + FcChar8 name[1]; /* name extends beyond struct */ +} FcGlyphName; + +/* + * To perform case-insensitive string comparisons, a table + * is used which holds three different kinds of folding data. + * + * The first is a range of upper case values mapping to a range + * of their lower case equivalents. Within each range, the offset + * between upper and lower case is constant. + * + * The second is a range of upper case values which are interleaved + * with their lower case equivalents. + * + * The third is a set of raw unicode values mapping to a list + * of unicode values for comparison purposes. This allows conversion + * of ß to "ss" so that SS, ss and ß all match. A separate array + * holds the list of unicode values for each entry. + * + * These are packed into a single table. Using a binary search, + * the appropriate entry can be located. + */ + +#define FC_CASE_FOLD_RANGE 0 +#define FC_CASE_FOLD_EVEN_ODD 1 +#define FC_CASE_FOLD_FULL 2 + +typedef struct _FcCaseFold { + FcChar32 upper; + FcChar16 method : 2; + FcChar16 count : 14; + short offset; /* lower - upper for RANGE, table id for FULL */ +} FcCaseFold; + +#define FC_MAX_FILE_LEN 4096 + +#define FC_CACHE_MAGIC_MMAP 0xFC02FC04 +#define FC_CACHE_MAGIC_ALLOC 0xFC02FC05 + +struct _FcAtomic { + FcChar8 *file; /* original file name */ + FcChar8 *new; /* temp file name -- write data here */ + FcChar8 *lck; /* lockfile name (used for locking) */ + FcChar8 *tmp; /* tmpfile name (used for locking) */ +}; + +struct _FcConfig { + /* + * File names loaded from the configuration -- saved here as the + * cache file must be consulted before the directories are scanned, + * and those directives may occur in any order + */ + FcStrSet *configDirs; /* directories to scan for fonts */ + /* + * List of directories containing fonts, + * built by recursively scanning the set + * of configured directories + */ + FcStrSet *fontDirs; + /* + * List of directories containing cache files. + */ + FcStrSet *cacheDirs; + /* + * Names of all of the configuration files used + * to create this configuration + */ + FcStrSet *configFiles; /* config files loaded */ + /* + * Substitution instructions for patterns and fonts; + * maxObjects is used to allocate appropriate intermediate storage + * while performing a whole set of substitutions + * + * 0.. substitutions for patterns + * 1.. substitutions for fonts + * 2.. substitutions for scanned fonts + */ + FcPtrList *subst[FcMatchKindEnd]; + int maxObjects; /* maximum number of tests in all substs */ + /* + * List of patterns used to control font file selection + */ + FcStrSet *acceptGlobs; + FcStrSet *rejectGlobs; + FcFontSet *acceptPatterns; + FcFontSet *rejectPatterns; + /* + * The set of fonts loaded from the listed directories; the + * order within the set does not determine the font selection, + * except in the case of identical matches in which case earlier fonts + * match preferrentially + */ + FcFontSet *fonts[FcSetApplication + 1]; + /* + * Fontconfig can periodically rescan the system configuration + * and font directories. This rescanning occurs when font + * listing requests are made, but no more often than rescanInterval + * seconds apart. + */ + time_t rescanTime; /* last time information was scanned */ + int rescanInterval; /* interval between scans */ + + FcRef ref; /* reference count */ + + FcExprPage *expr_pool; /* pool of FcExpr's */ + + FcChar8 *sysRoot; /* override the system root directory */ + FcStrSet *availConfigFiles; /* config files available */ + FcPtrList *rulesetList; /* List of rulesets being installed */ + + FcFilterFontSetFunc filter_func; /* A predicate function to filter out config->fonts */ + FcDestroyFunc destroy_data_func; /* A callback function to destroy config->filter_data */ + void *filter_data; /* An user data to be used for filter_func */ + + FcBool prefer_app_fonts; /* Whether FcSetApplication has a priority than + FcSetSystem for lookup */ + + FcChar8 *default_lang; /* Primary language in default_langs */ + FcStrSet *default_langs; /* String sets of the default languages */ + FcChar8 *prgname; /* Program name of current process */ + FcChar8 *desktop_name; /* Current desktop name */ + + int warns; /* Bitfield of warning flags (FC_WARN_*) controlling which warnings to emit */ +}; + +typedef struct _FcFileTime { + time_t time; + FcBool set; +} FcFileTime; + +typedef struct _FcCharMap FcCharMap; + +typedef struct _FcStatFS FcStatFS; + +struct _FcStatFS { + FcBool is_remote_fs; + FcBool is_mtime_broken; +}; + +typedef struct _FcValuePromotionBuffer FcValuePromotionBuffer; + +struct _FcValuePromotionBuffer { + union { + double d; + int i; + long l; + char c[256]; /* Enlarge as needed */ + } u; +}; + +#ifdef _WIN32 +typedef _locale_t FcLocale; +typedef enum _FcLocaleMask { + FC_LC_CTYPE = LC_CTYPE, + FC_LC_NUMERIC = LC_NUMERIC, + FC_LC_TIME = LC_TIME, + FC_LC_COLLATE = LC_COLLATE, + FC_LC_MONETARY = LC_MONETARY, + FC_LC_MESSAGES = LC_ALL, /* not available */ + FC_LC_PAPER = LC_ALL, + FC_LC_NAME = LC_ALL, + FC_LC_ADDRESS = LC_ALL, + FC_LC_TELEPHONE = LC_ALL, + FC_LC_MEASUREMENT = LC_ALL, + FC_LC_IDENTIFICATION = LC_ALL, + FC_LC_ALL = LC_ALL, +} FcLocaleMask; +#else +typedef locale_t FcLocale; +typedef enum _FcLocaleMask { + FC_LC_CTYPE = LC_CTYPE_MASK, + FC_LC_NUMERIC = LC_NUMERIC_MASK, + FC_LC_TIME = LC_TIME_MASK, + FC_LC_COLLATE = LC_COLLATE_MASK, + FC_LC_MONETARY = LC_MONETARY_MASK, + FC_LC_MESSAGES = LC_MESSAGES_MASK, +#ifdef LC_PAPER_MASK + FC_LC_PAPER = LC_PAPER_MASK, +#else + FC_LC_PAPER = LC_ALL_MASK, +#endif +#ifdef LC_NAME_MASK + FC_LC_NAME = LC_NAME_MASK, +#else + FC_LC_NAME = LC_ALL_MASK, +#endif +#ifdef LC_ADDRESS_MASK + FC_LC_ADDRESS = LC_ADDRESS_MASK, +#else + FC_LC_ADDRESS = LC_ALL_MASK, +#endif +#ifdef LC_TELEPHONE_MASK + FC_LC_TELEPHONE = LC_TELEPHONE_MASK, +#else + FC_LC_TELEPHONE = LC_ALL_MASK, +#endif +#ifdef LC_MEASUREMENT_MASK + FC_LC_MEASUREMENT = LC_MEASUREMENT_MASK, +#else + FC_LC_MEASUREMENT = LC_ALL_MASK, +#endif +#ifdef LC_IDENTIFICATION_MASK + FC_LC_IDENTIFICATION = LC_IDENTIFICATION_MASK, +#else + FC_LC_IDENTIFICATION = LC_ALL_MASK, +#endif + FC_LC_ALL = LC_ALL_MASK, +} FcLocaleMask; +#endif + +/* fccache.c */ + +FcPrivate FcCache * +FcDirCacheScan (const FcChar8 *dir, FcConfig *config); + +FcPrivate FcCache * +FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, struct stat *dir_stat, FcStrSet *dirs); + +FcPrivate FcCache * +FcDirCacheRebuild (FcCache *cache, struct stat *dir_stat, FcStrSet *dirs); + +FcPrivate FcBool +FcDirCacheWrite (FcCache *cache, FcConfig *config); + +FcPrivate FcBool +FcDirCacheCreateTagFile (const FcChar8 *cache_dir); + +FcPrivate void +FcCacheObjectReference (void *object); + +FcPrivate void +FcCacheObjectDereference (void *object); + +FcPrivate void * +FcCacheAllocate (FcCache *cache, size_t len); + +FcPrivate void +FcCacheFini (void); + +FcPrivate void +FcDirCacheReference (FcCache *cache, int nref); + +FcPrivate int +FcDirCacheLock (const FcChar8 *dir, + FcConfig *config); + +FcPrivate void +FcDirCacheUnlock (int fd); + +/* fccfg.c */ + +FcPrivate FcBool +FcConfigInit (void); + +FcPrivate void +FcConfigFini (void); + +FcPrivate FcChar8 * +FcConfigXdgCacheHome (void); + +FcPrivate FcChar8 * +FcConfigXdgConfigHome (void); + +FcPrivate FcChar8 * +FcConfigXdgDataHome (void); + +FcPrivate FcStrSet * +FcConfigXdgDataDirs (void); + +FcPrivate FcExpr * +FcConfigAllocExpr (FcConfig *config); + +FcPrivate FcBool +FcConfigAddConfigDir (FcConfig *config, + const FcChar8 *d); + +FcPrivate FcBool +FcConfigAddFontDir (FcConfig *config, + const FcChar8 *d, + const FcChar8 *m, + const FcChar8 *salt); + +FcPrivate FcBool +FcConfigResetFontDirs (FcConfig *config); + +FcPrivate FcChar8 * +FcConfigMapFontPath (FcConfig *config, + const FcChar8 *path); + +FcPrivate const FcChar8 * +FcConfigMapSalt (FcConfig *config, + const FcChar8 *path); + +FcPrivate FcBool +FcConfigAddCacheDir (FcConfig *config, + const FcChar8 *d); + +FcPrivate FcBool +FcConfigAddConfigFile (FcConfig *config, + const FcChar8 *f); + +FcPrivate FcBool +FcConfigAddBlank (FcConfig *config, + FcChar32 blank); + +FcBool +FcConfigAddRule (FcConfig *config, + FcRule *rule, + FcMatchKind kind); + +FcPrivate void +FcConfigSetFonts (FcConfig *config, + FcFontSet *fonts, + FcSetName set); + +FcPrivate FcBool +FcConfigCompareValue (const FcValue *m, + unsigned int op_, + const FcValue *v); + +FcPrivate FcBool +FcConfigGlobAdd (FcConfig *config, + const FcChar8 *glob, + FcBool accept); + +FcPrivate FcBool +FcConfigPatternsAdd (FcConfig *config, + FcPattern *pattern, + FcBool accept); + +FcPrivate FcFileTime +FcConfigModifiedTime (FcConfig *config); + +FcPrivate FcBool +FcConfigAddCache (FcConfig *config, FcCache *cache, + FcSetName set, FcStrSet *dirSet, FcChar8 *forDir); + +FcPrivate FcRuleSet * +FcRuleSetCreate (const FcChar8 *name); + +FcPrivate void +FcRuleSetDestroy (FcRuleSet *rs); + +FcPrivate void +FcRuleSetReference (FcRuleSet *rs); + +FcPrivate void +FcRuleSetEnable (FcRuleSet *rs, + FcBool flag); + +FcPrivate void +FcRuleSetAddDescription (FcRuleSet *rs, + const FcChar8 *domain, + const FcChar8 *description); + +FcPrivate int +FcRuleSetAdd (FcRuleSet *rs, + FcRule *rule, + FcMatchKind kind); + +/* fcserialize.c */ +FcPrivate intptr_t +FcAlignSize (intptr_t size); + +FcPrivate FcSerialize * +FcSerializeCreate (void); + +FcPrivate void +FcSerializeDestroy (FcSerialize *serialize); + +FcPrivate FcBool +FcSerializeAlloc (FcSerialize *serialize, const void *object, int size); + +FcPrivate intptr_t +FcSerializeReserve (FcSerialize *serialize, int size); + +FcPrivate intptr_t +FcSerializeOffset (FcSerialize *serialize, const void *object); + +FcPrivate void * +FcSerializePtr (FcSerialize *serialize, const void *object); + +FcPrivate FcBool +FcLangSetSerializeAlloc (FcSerialize *serialize, const FcLangSet *l); + +FcPrivate FcLangSet * +FcLangSetSerialize (FcSerialize *serialize, const FcLangSet *l); + +/* fccharset.c */ +FcPrivate FcCharSet * +FcCharSetPromote (FcValuePromotionBuffer *vbuf); + +FcPrivate void +FcLangCharSetPopulate (void); + +FcPrivate FcBool +FcLangIsExclusive (const FcChar8 *lang); + +FcPrivate const FcChar8 * +FcLangIsExclusiveFromOs2 (unsigned long os2ulUnicodeRange1, unsigned long os2ulUnicodeRange2); + +FcPrivate FcCharSetFreezer * +FcCharSetFreezerCreate (void); + +FcPrivate const FcCharSet * +FcCharSetFreeze (FcCharSetFreezer *freezer, const FcCharSet *fcs); + +FcPrivate void +FcCharSetFreezerDestroy (FcCharSetFreezer *freezer); + +FcPrivate FcBool +FcNameUnparseCharSet (FcStrBuf *buf, const FcCharSet *c); + +FcPrivate FcCharSet * +FcNameParseCharSet (FcChar8 *string); + +FcPrivate FcBool +FcNameUnparseValue (FcStrBuf *buf, + FcValue *v0, + FcChar8 *escape); + +FcPrivate FcBool +FcNameUnparseValueList (FcStrBuf *buf, + FcValueListPtr v, + FcChar8 *escape); + +FcPrivate FcCharLeaf * +FcCharSetFindLeafCreate (FcCharSet *fcs, FcChar32 ucs4); + +FcPrivate FcBool +FcCharSetSerializeAlloc (FcSerialize *serialize, const FcCharSet *cs); + +FcPrivate FcCharSet * +FcCharSetSerialize (FcSerialize *serialize, const FcCharSet *cs); + +FcPrivate FcChar16 * +FcCharSetGetNumbers (const FcCharSet *c); + +/* fccompat.c */ +FcPrivate int +FcOpen (const char *pathname, int flags, ...); + +FcPrivate int +FcMakeTempfile (char *template); + +FcPrivate int32_t +FcRandom (void); + +FcPrivate FcBool +FcMakeDirectory (const FcChar8 *dir); + +FcPrivate ssize_t +FcReadLink (const FcChar8 *pathname, + FcChar8 *buf, + size_t bufsiz); + +FcPrivate FcLocale +FcLocaleCreate (FcLocaleMask mask, const char *locale); + +#ifndef _WIN32 +FcPrivate FcLocale +FcLocaleSetCurrent (FcLocale loc); +#endif + +FcPrivate void +FcLocaleDestroy (FcLocale locale); + +/* fcconffile.c */ +#if HAVE_VASPRINTF_L +# define FcStrDupVapFormat(__ret__, __format__, __va__) \ + { \ + FcLocale loc = FcLocaleCreate (FC_LC_NUMERIC, "C"); \ + if (vasprintf_l (&(__ret__), loc, __format__, __va__) < 0) { \ + (__ret__) = NULL; \ + } \ + FcLocaleDestroy (loc); \ + } +#elif HAVE__VSNPRINTF_L +# define FcStrDupVapFormat(__ret__, __format__, __va__) \ + { \ + char FcStrDupVapFormat_c; \ + va_list FcStrDupVapFormat_va; \ + int FcStrDupVapFormat_size; \ + FcLocale loc = FcLocaleCreate (FC_LC_NUMERIC, "C"); \ + \ + (__ret__) = NULL; \ + va_copy (FcStrDupVapFormat_va, __va__); \ + FcStrDupVapFormat_size = vsnprintf (&FcStrDupVapFormat_c, 1, __format__, __va__) + 1; \ + va_end (FcStrDupVapFormat_va); \ + if (FcStrDupVapFormat_size > 0) { \ + (__ret__) = malloc (FcStrDupVapFormat_size); \ + if ((__ret__)) { \ + _vsnprintf_l ((__ret__), FcStrDupVapFormat_size, __format__, loc, __va__); \ + } \ + } \ + FcLocaleDestroy (loc); \ + } +#elif HAVE_VASPRINTF +# define FcStrDupVapFormat(__ret__, __format__, __va__) \ + { \ + FcLocale loc = FcLocaleCreate (FC_LC_NUMERIC, "C"); \ + FcLocale oldloc = FcLocaleSetCurrent (loc); \ + if (vasprintf (&(__ret__), __format__, __va__) < 0) { \ + (__ret__) = NULL; \ + } \ + FcLocaleSetCurrent (oldloc); \ + FcLocaleDestroy (loc); \ + } +#elif HAVE_C99_VSNPRINTF +# define FcStrDupVapFormat(__ret__, __format__, __va__) \ + { \ + char FcStrDupVapFormat_c; \ + va_list FcStrDupVapFormat_va; \ + int FcStrDupVapFormat_size; \ + FcLocale loc = FcLocaleCreate (FC_LC_NUMERIC, "C"); \ + FcLocale oldloc = FcLocaleSetCurrent (loc); \ + \ + (__ret__) = NULL; \ + va_copy (FcStrDupVapFormat_va, __va__); \ + FcStrDupVapFormat_size = vsnprintf (&FcStrDupVapFormat_c, 1, __format__, __va__) + 1; \ + va_end (FcStrDupVapFormat_va); \ + if (FcStrDupVapFormat_size > 0) { \ + (__ret__) = malloc (FcStrDupVapFormat_size); \ + if ((__ret__)) { \ + vsprintf ((__ret__), __format__, __va__); \ + } \ + } \ + FcLocaleSetCurrent (oldloc); \ + FcLocaleDestroy (loc); \ + } +#elif HAVE_VSNPRINTF +# define FcStrDupVapFormat(__ret__, __format__, __va__) \ + { \ + va_list FcStrDupVapFormat_va; \ + int FcStrDupVapFormat_size = 1024, FcStrDupVapFormat_n; \ + char *FcStrDupVapFormat_p; \ + FcLocale loc = FcLocaleCreate (FC_LC_NUMERIC, "C"); \ + FcLocale oldloc = FcLocaleSetCurrent (loc); \ + \ + (__ret__) = malloc (FcStrDupVapFormat_size); \ + if ((__ret__)) { \ + while (1) { \ + va_copy (FcStrDupVapFormat_va, __va__); \ + FcStrDupVapFormat_n = vsnprintf ((__ret__), FcStrDupVapFormat_size, __format__, FcStrDupVapFormat_va); \ + va_end (FcStrDupVapFormat_va); \ + if (FcStrDupVapFormat_n > -1 && \ + FcStrDupVapFormat_n < FcStrDupVapFormat_size) \ + break; \ + if (FcStrDupVapFormat_n > -1) \ + FcStrDupVapFormat_size = FcStrDupVapFormat_n + 1; \ + else \ + FcStrDupVapFormat_size *= 2; \ + FcStrDupVapFormat_p = realloc ((__ret__), FcStrDupVapFormat_size); \ + if (!FcStrDupVapFormat_p) { \ + free ((__ret__)); \ + (__ret__) = NULL; \ + break; \ + } \ + (__ret__) = FcStrDupVapFormat_p; \ + } \ + } \ + FcLocaleSetCurrent (oldloc); \ + FcLocaleDestroy (loc); \ + } +#else +# error no vsnprintf function implemented +#endif + +#define FcStrBufVapFormat(__ret__, __buf__, __format__, __va__) \ + { \ + char *FcStrBufVapFormat_p = NULL; \ + FcStrDupVapFormat (FcStrBufVapFormat_p, __format__, __va__); \ + if (!FcStrBufVapFormat_p) { \ + FcStrBufDestroy (__buf__); \ + (__ret__) = FcFalse; \ + } else { \ + FcStrBufString (__buf__, (const FcChar8 *)FcStrBufVapFormat_p); \ + free (FcStrBufVapFormat_p); \ + (__ret__) = FcTrue; \ + } \ + } + +/* fcdbg.c */ + +FcPrivate void +FcValuePrintFile (FILE *stream, const FcValue v); + +FcPrivate void +FcValuePrintFileWithPosition (FILE *stream, const FcValue v, FcBool show_pos_mark); + +FcPrivate void +FcValuePrintWithPosition (const FcValue v, FcBool show_pos_mark); + +FcPrivate void +FcValueListPrintFileWithPosition (FILE *stream, FcValueListPtr l, const FcValueListPtr pos); + +FcPrivate void +FcValueListPrintWithPosition (FcValueListPtr l, const FcValueListPtr pos); + +FcPrivate void +FcValueListPrintFile (FILE *stream, FcValueListPtr l); + +FcPrivate void +FcValueListPrint (FcValueListPtr l); + +FcPrivate void +FcLangSetPrintFile (FILE *stream, const FcLangSet *ls); + +FcPrivate void +FcLangSetPrint (const FcLangSet *ls); + +FcPrivate void +FcOpPrintFile (FILE *stream, FcOp op_); + +FcPrivate void +FcOpPrint (FcOp op); + +FcPrivate void +FcTestPrintFile (FILE *stream, const FcTest *test); + +FcPrivate void +FcTestPrint (const FcTest *test); + +FcPrivate void +FcExprPrintFile (FILE *stream, const FcExpr *expr); + +FcPrivate void +FcExprPrint (const FcExpr *expr); + +FcPrivate void +FcEditPrintFile (FILE *stream, const FcEdit *edit); + +FcPrivate void +FcEditPrint (const FcEdit *edit); + +FcPrivate void +FcRulePrintFile (FILE *stream, const FcRule *rule); + +FcPrivate void +FcRulePrint (const FcRule *rule); + +FcPrivate void +FcCharSetPrintFile (FILE *stream, const FcCharSet *c); + +FcPrivate void +FcCharSetPrint (const FcCharSet *c); + +FcPrivate void +FcPatternPrintFile (FILE *stream, const FcPattern *p); + +FcPrivate void +FcPatternPrint2File (FILE *stream, + FcPattern *pp1, + FcPattern *pp2, + const FcObjectSet *os); + +FcPrivate void +FcPatternPrint2 (FcPattern *p1, FcPattern *p2, const FcObjectSet *os); + +FcPrivate void +FcFontSetPrintFile (FILE *stream, const FcFontSet *s); + +extern FcPrivate int FcDebugVal; + +#define FcDebug() (FcDebugVal) + +FcPrivate void +FcInitDebug (void); + +/* fcdefault.c */ +FcPrivate FcChar8 * +FcConfigGetDefaultLang (FcConfig *config); + +FcPrivate FcChar8 * +FcGetDefaultLang (void); + +FcPrivate FcChar8 * +FcConfigGetPrgname (FcConfig *config); + +FcPrivate FcChar8 * +FcGetPrgname (void); + +FcPrivate FcChar8 * +FcConfigGetDesktopName (FcConfig *config); + +FcPrivate FcChar8 * +FcGetDesktopName (void); + +/* fcdir.c */ + +FcPrivate FcBool +FcFileIsLink (const FcChar8 *file); + +FcPrivate FcBool +FcFileIsFile (const FcChar8 *file); + +FcPrivate FcBool +FcFileScanConfig (FcFontSet *set, + FcStrSet *dirs, + const FcChar8 *file, + FcConfig *config); + +FcPrivate FcBool +FcDirScanConfig (FcFontSet *set, + FcStrSet *dirs, + const FcChar8 *dir, + FcBool force, + FcConfig *config); + +/* fcfont.c */ +FcPrivate int +FcFontDebug (void); + +/* fcfs.c */ + +FcPrivate FcBool +FcFontSetSerializeAlloc (FcSerialize *serialize, const FcFontSet *s); + +FcPrivate FcFontSet * +FcFontSetSerialize (FcSerialize *serialize, const FcFontSet *s); + +FcPrivate FcFontSet * +FcFontSetDeserialize (const FcFontSet *set); + +/* fcgenericalias.c */ +FcPrivate uint32_t +FcGenericAliasGetClassification (const char *family); + +/* fcplist.c */ +FcPrivate FcPtrList * +FcPtrListCreate (FcDestroyFunc func); + +FcPrivate void +FcPtrListDestroy (FcPtrList *list); + +FcPrivate void +FcPtrListIterInit (const FcPtrList *list, + FcPtrListIter *iter); + +FcPrivate void +FcPtrListIterInitAtLast (FcPtrList *list, + FcPtrListIter *iter); + +FcPrivate FcBool +FcPtrListIterNext (const FcPtrList *list, + FcPtrListIter *iter); + +FcPrivate FcBool +FcPtrListIterIsValid (const FcPtrList *list, + const FcPtrListIter *iter); + +FcPrivate void * +FcPtrListIterGetValue (const FcPtrList *list, + const FcPtrListIter *iter); + +FcPrivate FcBool +FcPtrListIterAdd (FcPtrList *list, + FcPtrListIter *iter, + void *data); + +FcPrivate FcBool +FcPtrListIterRemove (FcPtrList *list, + FcPtrListIter *iter); + +/* fcinit.c */ +FcPrivate FcConfig * +FcInitLoadOwnConfig (FcConfig *config); + +FcPrivate FcConfig * +FcInitLoadOwnConfigAndFonts (FcConfig *config); + +/* fcxml.c */ +FcPrivate void +FcConfigPathFini (void); + +FcPrivate void +FcTestDestroy (FcTest *test); + +FcPrivate void +FcEditDestroy (FcEdit *e); + +void +FcRuleDestroy (FcRule *rule); + +/* fclang.c */ +typedef struct { + const FcChar8 lang[16]; + const FcCharSet charset; +} FcLangCharSet; + +typedef struct { + int begin; + int end; +} FcLangCharSetRange; + +#include "fclang.h" + +struct _FcLangSet { + FcStrSet *extra; + FcChar32 map_size; + FcChar32 map[NUM_LANG_SET_MAP]; +}; + +FcPrivate FcLangSet * +FcLangSetFromCharSet (const FcCharSet *charset, + const FcChar8 *exclusiveLang); + +FcPrivate FcLangResult +FcLangCompare (const FcChar8 *s1, const FcChar8 *s2); + +FcPrivate FcLangSet * +FcLangSetPromote (const FcChar8 *lang, FcValuePromotionBuffer *buf); + +FcPrivate FcLangSet * +FcNameParseLangSet (const FcChar8 *string); + +FcPrivate FcBool +FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls); + +FcPrivate FcChar8 * +FcNameUnparseEscaped (FcPattern *pat, FcBool escape); + +FcPrivate FcBool +FcConfigParseOnly (FcConfig *config, + const FcChar8 *name, + FcBool complain); + +FcPrivate FcChar8 * +FcConfigRealFilename (FcConfig *config, + const FcChar8 *url); + +/* fclist.c */ + +FcPrivate FcBool +FcListPatternMatchAny (const FcPattern *p, + const FcPattern *font); + +/* fcmatch.c */ + +/* fcname.c */ + +enum { + FC_INVALID_OBJECT = 0, +#define FC_OBJECT(NAME, Type, Cmp) FC_##NAME##_OBJECT, +#include "fcobjs.h" +#undef FC_OBJECT + FC_ONE_AFTER_MAX_BASE_OBJECT +#define FC_MAX_BASE_OBJECT (FC_ONE_AFTER_MAX_BASE_OBJECT - 1) +}; + +FcPrivate FcBool +FcNameConstantWithObjectCheck (const FcChar8 *string, FcObject object, int *result); + +FcPrivate const FcChar8 * +FcNameGetConstantNameFromObject (FcObject object, int value); + +FcPrivate FcBool +FcNameBool (const FcChar8 *v, FcBool *result); + +FcPrivate FcBool +FcObjectValidType (FcObject object, FcType type); + +FcPrivate FcObject +FcObjectFromName (const char *name); + +FcPrivate const char * +FcObjectName (FcObject object); + +FcPrivate FcObjectSet * +FcObjectGetSet (void); + +#define FcObjectCompare(a, b) ((int)a - (int)b) + +/* fcpat.c */ + +FcPrivate FcValue +FcValueCanonicalize (const FcValue *v); + +FcPrivate FcValueListPtr +FcValueListCreate (void); + +FcPrivate void +FcValueListDestroy (FcValueListPtr l); + +FcPrivate FcValueListPtr +FcValueListPrepend (FcValueListPtr vallist, + FcValue value, + FcValueBinding binding); + +FcPrivate FcValueListPtr +FcValueListAppend (FcValueListPtr vallist, + FcValue value, + FcValueBinding binding); + +FcPrivate FcValueListPtr +FcValueListDuplicate (FcValueListPtr orig); + +FcPrivate FcPatternElt * +FcPatternObjectFindElt (const FcPattern *p, FcObject object); + +FcPrivate FcPatternElt * +FcPatternObjectInsertElt (FcPattern *p, FcObject object); + +FcPrivate FcBool +FcPatternObjectListAdd (FcPattern *p, + FcObject object, + FcValueListPtr list, + FcBool append); + +FcPrivate FcBool +FcPatternObjectAddWithBinding (FcPattern *p, + FcObject object, + FcValue value, + FcValueBinding binding, + FcBool append); + +FcPrivate FcBool +FcPatternObjectAdd (FcPattern *p, FcObject object, FcValue value, FcBool append); + +FcPrivate FcBool +FcPatternObjectAddWeak (FcPattern *p, FcObject object, FcValue value, FcBool append); + +FcPrivate FcResult +FcPatternObjectGetWithBinding (const FcPattern *p, FcObject object, int id, FcValue *v, FcValueBinding *b); + +FcPrivate FcResult +FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v); + +FcPrivate FcBool +FcPatternObjectDel (FcPattern *p, FcObject object); + +FcPrivate FcBool +FcPatternObjectRemove (FcPattern *p, FcObject object, int id); + +FcPrivate FcBool +FcPatternObjectAddInteger (FcPattern *p, FcObject object, int i); + +FcPrivate FcBool +FcPatternObjectAddDouble (FcPattern *p, FcObject object, double d); + +FcPrivate FcBool +FcPatternObjectAddString (FcPattern *p, FcObject object, const FcChar8 *s); + +FcPrivate FcBool +FcPatternObjectAddMatrix (FcPattern *p, FcObject object, const FcMatrix *s); + +FcPrivate FcBool +FcPatternObjectAddCharSet (FcPattern *p, FcObject object, const FcCharSet *c); + +FcPrivate FcBool +FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b); + +FcPrivate FcBool +FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls); + +FcPrivate FcBool +FcPatternObjectAddRange (FcPattern *p, FcObject object, const FcRange *r); + +FcPrivate FcResult +FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i); + +FcPrivate FcResult +FcPatternObjectGetDouble (const FcPattern *p, FcObject object, int n, double *d); + +FcPrivate FcResult +FcPatternObjectGetString (const FcPattern *p, FcObject object, int n, FcChar8 **s); + +FcPrivate FcResult +FcPatternObjectGetMatrix (const FcPattern *p, FcObject object, int n, FcMatrix **s); + +FcPrivate FcResult +FcPatternObjectGetCharSet (const FcPattern *p, FcObject object, int n, FcCharSet **c); + +FcPrivate FcResult +FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b); + +FcPrivate FcResult +FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls); + +FcPrivate FcResult +FcPatternObjectGetRange (const FcPattern *p, FcObject object, int id, FcRange **r); + +FcPrivate FcBool +FcPatternAppend (FcPattern *p, FcPattern *s); + +FcPrivate int +FcPatternPosition (const FcPattern *p, const char *object); + +FcPrivate FcBool +FcPatternFindObjectIter (const FcPattern *pat, FcPatternIter *iter, FcObject object); + +FcPrivate FcObject +FcPatternIterGetObjectId (const FcPattern *pat, FcPatternIter *iter); + +FcPrivate FcValueListPtr +FcPatternIterGetValues (const FcPattern *pat, FcPatternIter *iter); + +FcPrivate FcPattern * +FcPatternCacheRewriteFile (const FcPattern *pat, FcCache *cache, const FcChar8 *relocated_font_file); + +FcPrivate FcChar32 +FcStringHash (const FcChar8 *s); + +FcPrivate FcBool +FcPatternSerializeAlloc (FcSerialize *serialize, const FcPattern *pat); + +FcPrivate FcPattern * +FcPatternSerialize (FcSerialize *serialize, const FcPattern *pat); + +FcPrivate FcBool +FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *pat); + +FcPrivate FcValueList * +FcValueListSerialize (FcSerialize *serialize, const FcValueList *pat); + +/* fcrender.c */ + +/* fcmatrix.c */ + +extern FcPrivate const FcMatrix FcIdentityMatrix; + +FcPrivate void +FcMatrixFree (FcMatrix *mat); + +/* fcrange.c */ + +FcPrivate FcRange * +FcRangePromote (double v, FcValuePromotionBuffer *vbuf); + +FcPrivate FcBool +FcRangeIsInRange (const FcRange *a, const FcRange *b); + +FcPrivate FcBool +FcRangeCompare (FcOp op, const FcRange *a, const FcRange *b); + +FcPrivate FcChar32 +FcRangeHash (const FcRange *r); + +FcPrivate FcBool +FcRangeSerializeAlloc (FcSerialize *serialize, const FcRange *r); + +FcPrivate FcRange * +FcRangeSerialize (FcSerialize *serialize, const FcRange *r); + +/* fcstat.c */ + +FcPrivate int +FcStat (const FcChar8 *file, struct stat *statb); + +FcPrivate int +FcStatChecksum (const FcChar8 *file, struct stat *statb); + +FcPrivate FcBool +FcIsFsMmapSafe (int fd); + +FcPrivate FcBool +FcIsFsMtimeBroken (const FcChar8 *dir); + +/* fcstr.c */ +FcPrivate double +FcStrtod (char *s, char **end); + +FcPrivate FcChar8 * +FcStrDupVaFormat (const char *format, va_list va); + +FcPrivate FcChar8 * +FcStrDupFormat (const char *format, ...); + +FcPrivate FcStrSet * +FcStrSetCreateEx (unsigned int control); + +FcPrivate FcBool +FcStrSetInsert (FcStrSet *set, const FcChar8 *s, int pos); + +FcPrivate FcBool +FcStrSetAddLangs (FcStrSet *strs, const char *languages); + +FcPrivate void +FcStrSetSort (FcStrSet *set); + +FcPrivate FcBool +FcStrSetMemberAB (FcStrSet *set, const FcChar8 *a, FcChar8 *b, FcChar8 **ret); + +FcPrivate FcBool +FcStrSetAddTriple (FcStrSet *set, const FcChar8 *a, const FcChar8 *b, const FcChar8 *c); + +FcPrivate const FcChar8 * +FcStrTripleSecond (FcChar8 *s); + +FcPrivate const FcChar8 * +FcStrTripleThird (FcChar8 *str); + +FcPrivate FcBool +FcStrSetAddFilenamePairWithSalt (FcStrSet *strs, const FcChar8 *d, const FcChar8 *m, const FcChar8 *salt); + +FcPrivate FcBool +FcStrSetDeleteAll (FcStrSet *set); + +FcPrivate void +FcStrBufInit (FcStrBuf *buf, FcChar8 *init, int size); + +FcPrivate void +FcStrBufDestroy (FcStrBuf *buf); + +FcPrivate FcChar8 * +FcStrBufDone (FcStrBuf *buf); + +FcPrivate FcChar8 * +FcStrBufDoneStatic (FcStrBuf *buf); + +FcPrivate FcBool +FcStrBufChar (FcStrBuf *buf, FcChar8 c); + +FcPrivate FcBool +FcStrBufString (FcStrBuf *buf, const FcChar8 *s); + +FcPrivate FcBool +FcStrBufVaFormat (FcStrBuf *buf, const char *format, va_list va); + +FcPrivate FcBool +FcStrBufFormat (FcStrBuf *buf, const char *format, ...); + +FcPrivate FcBool +FcStrBufData (FcStrBuf *buf, const FcChar8 *s, int len); + +FcPrivate int +FcStrCmpIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2); + +FcPrivate int +FcStrCmpIgnoreCaseAndDelims (const FcChar8 *s1, const FcChar8 *s2, const FcChar8 *delims); + +FcPrivate const FcChar8 * +FcStrContainsIgnoreBlanksAndCase (const FcChar8 *s1, const FcChar8 *s2); + +FcPrivate const FcChar8 * +FcStrContainsIgnoreCase (const FcChar8 *s1, const FcChar8 *s2); + +FcPrivate const FcChar8 * +FcStrContainsWord (const FcChar8 *s1, const FcChar8 *s2); + +FcPrivate int +FcStrMatchIgnoreCaseAndDelims (const FcChar8 *s1, const FcChar8 *s2, const FcChar8 *delims); + +FcPrivate FcBool +FcStrGlobMatch (const FcChar8 *glob, + const FcChar8 *string); + +FcPrivate FcBool +FcStrUsesHome (const FcChar8 *s); + +FcPrivate FcBool +FcStrIsAbsoluteFilename (const FcChar8 *s); + +FcPrivate FcChar8 * +FcStrLastSlash (const FcChar8 *path); + +FcPrivate FcChar32 +FcStrHashIgnoreCase (const FcChar8 *s); + +FcPrivate FcChar32 +FcStrHashIgnoreBlanksAndCase (const FcChar8 *s); + +FcPrivate FcChar8 * +FcStrRealPath (const FcChar8 *path); + +FcPrivate FcChar8 * +FcStrCanonFilename (const FcChar8 *s); + +FcPrivate FcBool +FcStrSerializeAlloc (FcSerialize *serialize, const FcChar8 *str); + +FcPrivate FcChar8 * +FcStrSerialize (FcSerialize *serialize, const FcChar8 *str); + +/* fcobjs.c */ +FcPrivate void +FcObjectInit (void); + +FcPrivate void +FcObjectFini (void); + +FcPrivate FcObject +FcObjectLookupIdByName (const char *str); + +FcPrivate FcObject +FcObjectLookupBuiltinIdByName (const char *str); + +FcPrivate const char * +FcObjectLookupOtherNameById (FcObject id); + +FcPrivate const FcObjectType * +FcObjectLookupOtherTypeById (FcObject id); + +FcPrivate const FcObjectType * +FcObjectLookupOtherTypeByName (const char *str); + +/* fchash.c */ +FcPrivate FcBool +FcHashStrCopy (const void *src, + void **dest); + +FcPrivate FcBool +FcHashUuidCopy (const void *src, + void **dest); + +FcPrivate void +FcHashUuidFree (void *data); + +FcPrivate FcHashTable * +FcHashTableCreate (FcHashFunc hash_func, + FcCompareFunc compare_func, + FcCopyFunc key_copy_func, + FcCopyFunc value_copy_func, + FcDestroyFunc key_destroy_func, + FcDestroyFunc value_destroy_func); + +FcPrivate void +FcHashTableDestroy (FcHashTable *table); + +FcPrivate FcBool +FcHashTableFind (FcHashTable *table, + const void *key, + void **value); + +FcPrivate FcBool +FcHashTableAdd (FcHashTable *table, + void *key, + void *value); + +FcPrivate FcBool +FcHashTableReplace (FcHashTable *table, + void *key, + void *value); + +FcPrivate FcBool +FcHashTableRemove (FcHashTable *table, + void *key); + +#endif /* _FC_INT_H_ */ diff --git a/pkg/fontconfig/override/include/fcobjshash.h b/pkg/fontconfig/override/src/fcobjshash.h similarity index 53% rename from pkg/fontconfig/override/include/fcobjshash.h rename to pkg/fontconfig/override/src/fcobjshash.h index f06234ac3..6160272b5 100644 --- a/pkg/fontconfig/override/include/fcobjshash.h +++ b/pkg/fontconfig/override/src/fcobjshash.h @@ -1,4 +1,4 @@ -/* ANSI-C code produced by gperf version 3.1 */ +/* ANSI-C code produced by gperf version 3.3 */ /* Command-line: gperf --pic -m 100 fcobjshash.gperf */ /* Computed positions: -k'3,5' */ @@ -37,7 +37,7 @@ int name; int id; }; #include -/* maximum key range = 59, duplicates = 0 */ +/* maximum key range = 58, duplicates = 0 */ #ifdef __GNUC__ __inline @@ -51,32 +51,32 @@ FcObjectTypeHash (register const char *str, register size_t len) { static const unsigned char asso_values[] = { - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 4, 10, 32, - 21, 29, 28, 49, 14, 4, 66, 66, 5, 31, - 18, 22, 27, 66, 15, 9, 8, 23, 23, 13, - 23, 16, 4, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66 + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 0, 24, 36, + 21, 0, 34, 4, 8, 6, 62, 62, 23, 4, + 12, 41, 19, 62, 4, 0, 10, 13, 26, 37, + 16, 35, 2, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62 }; register unsigned int hval = len; @@ -84,6 +84,11 @@ FcObjectTypeHash (register const char *str, register size_t len) { default: hval += asso_values[(unsigned char)str[4]]; +#if (defined __cplusplus && (__cplusplus >= 201703L || (__cplusplus >= 201103L && defined __clang__ && __clang_major__ + (__clang_minor__ >= 9) > 3))) || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 202000L && ((defined __GNUC__ && __GNUC__ >= 10) || (defined __clang__ && __clang_major__ >= 9))) + [[fallthrough]]; +#elif (defined __GNUC__ && __GNUC__ >= 7) || (defined __clang__ && __clang_major__ >= 10) + __attribute__ ((__fallthrough__)); +#endif /*FALLTHROUGH*/ case 4: case 3: @@ -95,112 +100,120 @@ FcObjectTypeHash (register const char *str, register size_t len) struct FcObjectTypeNamePool_t { - char FcObjectTypeNamePool_str7[sizeof("dpi")]; - char FcObjectTypeNamePool_str8[sizeof("size")]; - char FcObjectTypeNamePool_str9[sizeof("file")]; - char FcObjectTypeNamePool_str13[sizeof("hash")]; - char FcObjectTypeNamePool_str14[sizeof("rgba")]; - char FcObjectTypeNamePool_str15[sizeof("spacing")]; - char FcObjectTypeNamePool_str16[sizeof("scalable")]; - char FcObjectTypeNamePool_str17[sizeof("slant")]; - char FcObjectTypeNamePool_str18[sizeof("matrix")]; - char FcObjectTypeNamePool_str19[sizeof("outline")]; - char FcObjectTypeNamePool_str20[sizeof("charset")]; - char FcObjectTypeNamePool_str21[sizeof("antialias")]; - char FcObjectTypeNamePool_str22[sizeof("lang")]; - char FcObjectTypeNamePool_str23[sizeof("embolden")]; - char FcObjectTypeNamePool_str24[sizeof("weight")]; - char FcObjectTypeNamePool_str25[sizeof("color")]; - char FcObjectTypeNamePool_str26[sizeof("charwidth")]; - char FcObjectTypeNamePool_str27[sizeof("variable")]; - char FcObjectTypeNamePool_str28[sizeof("charheight")]; - char FcObjectTypeNamePool_str29[sizeof("hinting")]; - char FcObjectTypeNamePool_str30[sizeof("autohint")]; - char FcObjectTypeNamePool_str31[sizeof("fullname")]; - char FcObjectTypeNamePool_str32[sizeof("postscriptname")]; - char FcObjectTypeNamePool_str33[sizeof("verticallayout")]; - char FcObjectTypeNamePool_str34[sizeof("lcdfilter")]; - char FcObjectTypeNamePool_str35[sizeof("fullnamelang")]; - char FcObjectTypeNamePool_str36[sizeof("hintstyle")]; - char FcObjectTypeNamePool_str37[sizeof("pixelsize")]; - char FcObjectTypeNamePool_str38[sizeof("scale")]; - char FcObjectTypeNamePool_str39[sizeof("globaladvance")]; - char FcObjectTypeNamePool_str40[sizeof("width")]; - char FcObjectTypeNamePool_str41[sizeof("order")]; - char FcObjectTypeNamePool_str42[sizeof("family")]; - char FcObjectTypeNamePool_str43[sizeof("fonthashint")]; - char FcObjectTypeNamePool_str44[sizeof("namelang")]; - char FcObjectTypeNamePool_str45[sizeof("embeddedbitmap")]; - char FcObjectTypeNamePool_str46[sizeof("familylang")]; - char FcObjectTypeNamePool_str47[sizeof("capability")]; - char FcObjectTypeNamePool_str48[sizeof("rasterizer")]; - char FcObjectTypeNamePool_str49[sizeof("index")]; - char FcObjectTypeNamePool_str50[sizeof("style")]; - char FcObjectTypeNamePool_str51[sizeof("foundry")]; - char FcObjectTypeNamePool_str52[sizeof("fontversion")]; - char FcObjectTypeNamePool_str53[sizeof("minspace")]; - char FcObjectTypeNamePool_str54[sizeof("stylelang")]; - char FcObjectTypeNamePool_str55[sizeof("fontvariations")]; + char FcObjectTypeNamePool_str4[sizeof("hash")]; + char FcObjectTypeNamePool_str5[sizeof("scale")]; + char FcObjectTypeNamePool_str6[sizeof("size")]; + char FcObjectTypeNamePool_str7[sizeof("charset")]; + char FcObjectTypeNamePool_str8[sizeof("scalable")]; + char FcObjectTypeNamePool_str9[sizeof("dpi")]; + char FcObjectTypeNamePool_str10[sizeof("rasterizer")]; + char FcObjectTypeNamePool_str11[sizeof("prgname")]; + char FcObjectTypeNamePool_str12[sizeof("variable")]; + char FcObjectTypeNamePool_str13[sizeof("spacing")]; + char FcObjectTypeNamePool_str14[sizeof("postscriptname")]; + char FcObjectTypeNamePool_str15[sizeof("slant")]; + char FcObjectTypeNamePool_str16[sizeof("lang")]; + char FcObjectTypeNamePool_str17[sizeof("desktop")]; + char FcObjectTypeNamePool_str18[sizeof("charheight")]; + char FcObjectTypeNamePool_str19[sizeof("antialias")]; + char FcObjectTypeNamePool_str20[sizeof("weight")]; + char FcObjectTypeNamePool_str21[sizeof("hintstyle")]; + char FcObjectTypeNamePool_str22[sizeof("matrix")]; + char FcObjectTypeNamePool_str23[sizeof("outline")]; + char FcObjectTypeNamePool_str24[sizeof("verticallayout")]; + char FcObjectTypeNamePool_str25[sizeof("hinting")]; + char FcObjectTypeNamePool_str26[sizeof("autohint")]; + char FcObjectTypeNamePool_str27[sizeof("file")]; + char FcObjectTypeNamePool_str28[sizeof("rgba")]; + char FcObjectTypeNamePool_str29[sizeof("genericfamily")]; + char FcObjectTypeNamePool_str30[sizeof("order")]; + char FcObjectTypeNamePool_str31[sizeof("fonthashint")]; + char FcObjectTypeNamePool_str32[sizeof("color")]; + char FcObjectTypeNamePool_str33[sizeof("family")]; + char FcObjectTypeNamePool_str34[sizeof("width")]; + char FcObjectTypeNamePool_str35[sizeof("namelang")]; + char FcObjectTypeNamePool_str36[sizeof("lcdfilter")]; + char FcObjectTypeNamePool_str37[sizeof("familylang")]; + char FcObjectTypeNamePool_str38[sizeof("namedinstance")]; + char FcObjectTypeNamePool_str39[sizeof("minspace")]; + char FcObjectTypeNamePool_str40[sizeof("style")]; + char FcObjectTypeNamePool_str41[sizeof("foundry")]; + char FcObjectTypeNamePool_str42[sizeof("index")]; + char FcObjectTypeNamePool_str43[sizeof("fullname")]; + char FcObjectTypeNamePool_str44[sizeof("stylelang")]; + char FcObjectTypeNamePool_str46[sizeof("charwidth")]; + char FcObjectTypeNamePool_str47[sizeof("fullnamelang")]; + char FcObjectTypeNamePool_str48[sizeof("pixelsize")]; + char FcObjectTypeNamePool_str49[sizeof("fontversion")]; + char FcObjectTypeNamePool_str50[sizeof("decorative")]; + char FcObjectTypeNamePool_str51[sizeof("symbol")]; + char FcObjectTypeNamePool_str52[sizeof("fontvariations")]; + char FcObjectTypeNamePool_str53[sizeof("capability")]; + char FcObjectTypeNamePool_str54[sizeof("globaladvance")]; + char FcObjectTypeNamePool_str55[sizeof("embolden")]; char FcObjectTypeNamePool_str56[sizeof("fontformat")]; - char FcObjectTypeNamePool_str57[sizeof("decorative")]; char FcObjectTypeNamePool_str58[sizeof("fontfeatures")]; - char FcObjectTypeNamePool_str59[sizeof("symbol")]; - char FcObjectTypeNamePool_str60[sizeof("prgname")]; - char FcObjectTypeNamePool_str65[sizeof("aspect")]; + char FcObjectTypeNamePool_str59[sizeof("embeddedbitmap")]; + char FcObjectTypeNamePool_str60[sizeof("fontwrapper")]; + char FcObjectTypeNamePool_str61[sizeof("aspect")]; }; static const struct FcObjectTypeNamePool_t FcObjectTypeNamePool_contents = { - "dpi", - "size", - "file", "hash", - "rgba", - "spacing", + "scale", + "size", + "charset", "scalable", + "dpi", + "rasterizer", + "prgname", + "variable", + "spacing", + "postscriptname", "slant", + "lang", + "desktop", + "charheight", + "antialias", + "weight", + "hintstyle", "matrix", "outline", - "charset", - "antialias", - "lang", - "embolden", - "weight", - "color", - "charwidth", - "variable", - "charheight", + "verticallayout", "hinting", "autohint", - "fullname", - "postscriptname", - "verticallayout", - "lcdfilter", - "fullnamelang", - "hintstyle", - "pixelsize", - "scale", - "globaladvance", - "width", + "file", + "rgba", + "genericfamily", "order", - "family", "fonthashint", + "color", + "family", + "width", "namelang", - "embeddedbitmap", + "lcdfilter", "familylang", - "capability", - "rasterizer", - "index", + "namedinstance", + "minspace", "style", "foundry", - "fontversion", - "minspace", + "index", + "fullname", "stylelang", - "fontvariations", - "fontformat", + "charwidth", + "fullnamelang", + "pixelsize", + "fontversion", "decorative", - "fontfeatures", "symbol", - "prgname", + "fontvariations", + "capability", + "globaladvance", + "embolden", + "fontformat", + "fontfeatures", + "embeddedbitmap", + "fontwrapper", "aspect" }; #define FcObjectTypeNamePool ((const char *) &FcObjectTypeNamePool_contents) @@ -209,123 +222,138 @@ FcObjectTypeLookup (register const char *str, register size_t len) { enum { - TOTAL_KEYWORDS = 52, + TOTAL_KEYWORDS = 56, MIN_WORD_LENGTH = 3, MAX_WORD_LENGTH = 14, - MIN_HASH_VALUE = 7, - MAX_HASH_VALUE = 65 + MIN_HASH_VALUE = 4, + MAX_HASH_VALUE = 61 }; +#if (defined __GNUC__ && __GNUC__ + (__GNUC_MINOR__ >= 6) > 4) || (defined __clang__ && __clang_major__ >= 3) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif static const struct FcObjectTypeInfo wordlist[] = { - {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, {-1}, -#line 43 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str7,FC_DPI_OBJECT}, -#line 27 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str8,FC_SIZE_OBJECT}, -#line 38 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str9,FC_FILE_OBJECT}, - {-1}, {-1}, {-1}, + {-1}, {-1}, {-1}, {-1}, #line 62 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str13,FC_HASH_OBJECT}, -#line 44 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str14,FC_RGBA_OBJECT}, -#line 30 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str15,FC_SPACING_OBJECT}, -#line 42 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str16,FC_SCALABLE_OBJECT}, -#line 24 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str17,FC_SLANT_OBJECT}, -#line 49 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str18,FC_MATRIX_OBJECT}, -#line 41 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str19,FC_OUTLINE_OBJECT}, -#line 50 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str20,FC_CHARSET_OBJECT}, -#line 32 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str21,FC_ANTIALIAS_OBJECT}, -#line 51 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str22,FC_LANG_OBJECT}, -#line 55 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str23,FC_EMBOLDEN_OBJECT}, -#line 25 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str24,FC_WEIGHT_OBJECT}, -#line 64 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str25,FC_COLOR_OBJECT}, -#line 47 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str26,FC_CHARWIDTH_OBJECT}, -#line 67 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str27,FC_VARIABLE_OBJECT}, -#line 48 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str28,FC_CHAR_HEIGHT_OBJECT}, -#line 34 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str29,FC_HINTING_OBJECT}, -#line 36 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str30,FC_AUTOHINT_OBJECT}, -#line 22 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str31,FC_FULLNAME_OBJECT}, -#line 63 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str32,FC_POSTSCRIPT_NAME_OBJECT}, -#line 35 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str33,FC_VERTICAL_LAYOUT_OBJECT}, -#line 58 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str34,FC_LCD_FILTER_OBJECT}, -#line 23 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str35,FC_FULLNAMELANG_OBJECT}, -#line 33 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str36,FC_HINT_STYLE_OBJECT}, -#line 29 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str37,FC_PIXEL_SIZE_OBJECT}, + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str4,FC_HASH_OBJECT}, #line 45 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str38,FC_SCALE_OBJECT}, -#line 37 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str39,FC_GLOBAL_ADVANCE_OBJECT}, -#line 26 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str40,FC_WIDTH_OBJECT}, -#line 69 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str41,FC_ORDER_OBJECT}, -#line 18 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str42,FC_FAMILY_OBJECT}, -#line 68 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str43,FC_FONT_HAS_HINT_OBJECT}, -#line 59 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str44,FC_NAMELANG_OBJECT}, -#line 56 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str45,FC_EMBEDDED_BITMAP_OBJECT}, -#line 19 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str46,FC_FAMILYLANG_OBJECT}, -#line 53 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str47,FC_CAPABILITY_OBJECT}, + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str5,FC_SCALE_OBJECT}, +#line 27 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str6,FC_SIZE_OBJECT}, +#line 50 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str7,FC_CHARSET_OBJECT}, +#line 42 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str8,FC_SCALABLE_OBJECT}, +#line 43 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str9,FC_DPI_OBJECT}, #line 40 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str48,FC_RASTERIZER_OBJECT}, -#line 39 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str49,FC_INDEX_OBJECT}, -#line 20 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str50,FC_STYLE_OBJECT}, -#line 31 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str51,FC_FOUNDRY_OBJECT}, -#line 52 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str52,FC_FONTVERSION_OBJECT}, + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str10,FC_RASTERIZER_OBJECT}, +#line 61 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str11,FC_PRGNAME_OBJECT}, +#line 67 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str12,FC_VARIABLE_OBJECT}, +#line 30 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str13,FC_SPACING_OBJECT}, +#line 63 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str14,FC_POSTSCRIPT_NAME_OBJECT}, +#line 24 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str15,FC_SLANT_OBJECT}, +#line 51 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str16,FC_LANG_OBJECT}, +#line 70 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str17,FC_DESKTOP_NAME_OBJECT}, +#line 48 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str18,FC_CHAR_HEIGHT_OBJECT}, +#line 32 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str19,FC_ANTIALIAS_OBJECT}, +#line 25 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str20,FC_WEIGHT_OBJECT}, +#line 33 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str21,FC_HINT_STYLE_OBJECT}, +#line 49 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str22,FC_MATRIX_OBJECT}, +#line 41 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str23,FC_OUTLINE_OBJECT}, +#line 35 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str24,FC_VERTICAL_LAYOUT_OBJECT}, +#line 34 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str25,FC_HINTING_OBJECT}, +#line 36 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str26,FC_AUTOHINT_OBJECT}, +#line 38 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str27,FC_FILE_OBJECT}, +#line 44 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str28,FC_RGBA_OBJECT}, +#line 73 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str29,FC_GENERIC_FAMILY_OBJECT}, +#line 69 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str30,FC_ORDER_OBJECT}, +#line 68 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str31,FC_FONT_HAS_HINT_OBJECT}, +#line 64 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str32,FC_COLOR_OBJECT}, +#line 18 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str33,FC_FAMILY_OBJECT}, +#line 26 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str34,FC_WIDTH_OBJECT}, +#line 59 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str35,FC_NAMELANG_OBJECT}, +#line 58 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str36,FC_LCD_FILTER_OBJECT}, +#line 19 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str37,FC_FAMILYLANG_OBJECT}, +#line 71 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str38,FC_NAMED_INSTANCE_OBJECT}, #line 46 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str53,FC_MINSPACE_OBJECT}, + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str39,FC_MINSPACE_OBJECT}, +#line 20 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str40,FC_STYLE_OBJECT}, +#line 31 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str41,FC_FOUNDRY_OBJECT}, +#line 39 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str42,FC_INDEX_OBJECT}, +#line 22 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str43,FC_FULLNAME_OBJECT}, #line 21 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str54,FC_STYLELANG_OBJECT}, + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str44,FC_STYLELANG_OBJECT}, + {-1}, +#line 47 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str46,FC_CHARWIDTH_OBJECT}, +#line 23 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str47,FC_FULLNAMELANG_OBJECT}, +#line 29 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str48,FC_PIXEL_SIZE_OBJECT}, +#line 52 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str49,FC_FONTVERSION_OBJECT}, +#line 57 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str50,FC_DECORATIVE_OBJECT}, +#line 65 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str51,FC_SYMBOL_OBJECT}, #line 66 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str55,FC_FONT_VARIATIONS_OBJECT}, + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str52,FC_FONT_VARIATIONS_OBJECT}, +#line 53 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str53,FC_CAPABILITY_OBJECT}, +#line 37 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str54,FC_GLOBAL_ADVANCE_OBJECT}, +#line 55 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str55,FC_EMBOLDEN_OBJECT}, #line 54 "fcobjshash.gperf" {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str56,FC_FONTFORMAT_OBJECT}, -#line 57 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str57,FC_DECORATIVE_OBJECT}, + {-1}, #line 60 "fcobjshash.gperf" {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str58,FC_FONT_FEATURES_OBJECT}, -#line 65 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str59,FC_SYMBOL_OBJECT}, -#line 61 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str60,FC_PRGNAME_OBJECT}, - {-1}, {-1}, {-1}, {-1}, +#line 56 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str59,FC_EMBEDDED_BITMAP_OBJECT}, +#line 72 "fcobjshash.gperf" + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str60,FC_FONT_WRAPPER_OBJECT}, #line 28 "fcobjshash.gperf" - {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str65,FC_ASPECT_OBJECT} + {(int)(size_t)&((struct FcObjectTypeNamePool_t *)0)->FcObjectTypeNamePool_str61,FC_ASPECT_OBJECT} }; +#if (defined __GNUC__ && __GNUC__ + (__GNUC_MINOR__ >= 6) > 4) || (defined __clang__ && __clang_major__ >= 3) +#pragma GCC diagnostic pop +#endif if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) { @@ -343,5 +371,5 @@ FcObjectTypeLookup (register const char *str, register size_t len) } } } - return 0; + return (struct FcObjectTypeInfo *) 0; } diff --git a/pkg/fontconfig/override/src/fcstdint.h b/pkg/fontconfig/override/src/fcstdint.h new file mode 100644 index 000000000..b61b0cb45 --- /dev/null +++ b/pkg/fontconfig/override/src/fcstdint.h @@ -0,0 +1,9 @@ +#ifndef _FONTCONFIG_SRC_FCSTDINT_H +#define _FONTCONFIG_SRC_FCSTDINT_H 1 +#ifndef _GENERATED_STDINT_H +#define _GENERATED_STDINT_H "fontconfig 2.18.3" +/* generated using gnu compiler gcc (GCC) 15.3.0 */ +#define _STDINT_HAVE_STDINT_H 1 +#include +#endif +#endif