diff options
author | Peter Breitenlohner <peb@mppmu.mpg.de> | 2015-01-14 10:59:36 +0000 |
---|---|---|
committer | Peter Breitenlohner <peb@mppmu.mpg.de> | 2015-01-14 10:59:36 +0000 |
commit | aa7bbf0e9b00afeeab12fb092b62976cf24fb439 (patch) | |
tree | c18d4ee9d969c2fca65036c7d9194d0961df61a3 /Build/source/libs/gd/libgd-2.1.1 | |
parent | 51f86fe156c11e441cc74238dc38b99f9576d1a9 (diff) |
libgd 2.1.1
git-svn-id: svn://tug.org/texlive/trunk@36054 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/libs/gd/libgd-2.1.1')
415 files changed, 72233 insertions, 0 deletions
diff --git a/Build/source/libs/gd/libgd-2.1.1/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/CMakeLists.txt new file mode 100644 index 00000000000..5bec7043208 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/CMakeLists.txt @@ -0,0 +1,283 @@ +# $Id$ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6 FATAL_ERROR) + +SET(PACKAGE GD) +SET(PACKAGE_NAME GD) + +CMAKE_POLICY(SET CMP0017 OLD) +PROJECT(GD) + +SET(CMAKE_MODULE_PATH "${GD_SOURCE_DIR}/cmake/modules") + +OPTION(ENABLE_PNG "Enable PNG support" 0) +OPTION(ENABLE_LIQ "Enable libimagequant support" 0) +OPTION(ENABLE_JPEG "Enable JPEG support" 0) +OPTION(ENABLE_TIFF "Enable TIFF support" 0) +OPTION(ENABLE_ICONV "Enable ICONV support" 0) +OPTION(ENABLE_XPM "Enable XPM support" 0) +OPTION(ENABLE_FREETYPE "Enable Freetype2 support" 0) +OPTION(ENABLE_FONTCONFIG "Enable FontConfig support" 0) +OPTION(ENABLE_WEBP "Enable WebP support" 0) + +if (BUILD_TEST) + ENABLE_TESTING() +endif(BUILD_TEST) + +# if you would like to pass C flags to the compiler, then just +# - specify -DCMAKE_C_FLAGS=... on invocation of cmake, or +# - specify CFLAGS=... on invocation of make +IF(CMAKE_COMPILER_IS_GNUCC) + SET(CMAKE_C_FLAGS_DEBUG "-g -Wall -Wextra -O0") # will be added to CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug" +ENDIF(CMAKE_COMPILER_IS_GNUCC) +SET (CMAKE_LIBRARY_OUTPUT_DIRECTORY + ${PROJECT_BINARY_DIR}/Bin + CACHE PATH + "Single Directory for all Libraries" + ) + +# --------- Setup the Executable output Directory ------------- +SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY + ${PROJECT_BINARY_DIR}/Bin + CACHE PATH + "Single Directory for all Executables." + ) + +# --------- Setup the Executable output Directory ------------- +SET (CMAKE_ARCHIVE_OUTPUT_DIRECTORY + ${PROJECT_BINARY_DIR}/Bin + CACHE PATH + "Single Directory for all static libraries." + ) + +if (USE_EXT_GD) + message("Using GD at: ${USE_EXT_GD}") + INCLUDE_DIRECTORIES(BEFORE ${GD_INCLUDE_DIR}) + FIND_PACKAGE(GD) + if (GD_FOUND) + INCLUDE_DIRECTORIES(BEFORE ${GD_INCLUDE_DIR}) + LINK_DIRECTORIES(${GD_LIBRARIES}) + SET(GD_LIB ${GD_LIBRARIES}) + SET(GD_LIBS_DIR ${GD_LIBRARY}) + + message("GD libs #: ${GD_LIBRARIES}") + message("GD lib #: ${GD_LIBRARY}") + message("GD include: ${GD_INCLUDE_DIR}") + else (GD_FOUND) + message("No gd found") + endif (GD_FOUND) +else (USE_EXT_GD) + + SET(GD_VERSION_MAJOR "2") + SET(GD_VERSION_MINOR "1") + SET(GD_VERSION_PATCH "1") + SET(GD_VERSION_EXTRA "") + SET(GD_VERSION "${GD_VERSION_MAJOR}.${GD_VERSION_MINOR}.${GD_VERSION_PATCH}${GD_VERSION_EXTRA}") + SET(GD_VERSION_STRING "${GD_VERSION}") + + SET(GD_VERSION_INT "20101") + + SET(CMAKE_REQUIRED_INCLUDES "/usr/include" "/usr/local/include") + + include(CheckIncludeFiles) + include(CheckIncludeFile) + + include(AC_HEADER_STDC) + include(CheckPrototypeExists) + + if (ENABLE_PNG) + FIND_PACKAGE(PNG REQUIRED) + endif (ENABLE_PNG) + + if (ENABLE_ICONV) + FIND_PACKAGE(ICONV REQUIRED) + endif (ENABLE_ICONV) + + FIND_PACKAGE(ZLIB) + + IF (ENABLE_WEBP) + FIND_PACKAGE(VPX) + ENDIF (ENABLE_WEBP) + + IF (ENABLE_LIQ) + FIND_PACKAGE(LIQ) + ENDIF (ENABLE_LIQ) + + IF (NOT WIN32) + FIND_PACKAGE(PTHREAD) + ENDIF (NOT WIN32) + + if (ENABLE_JPEG) + FIND_PACKAGE(JPEG) + endif (ENABLE_JPEG) + + if (ENABLE_TIFF) + FIND_PACKAGE(TIFF) + endif (ENABLE_TIFF) + + if (ENABLE_FREETYPE) + FIND_PACKAGE(Freetype) + endif (ENABLE_FREETYPE) + + if (ENABLE_XPM) + FIND_PACKAGE(XPM) + endif (ENABLE_XPM) + + if (ENABLE_FONTCONFIG) + FIND_PACKAGE(FontConfig) + endif (ENABLE_FONTCONFIG) + + if (FREETYPE_FOUND) + INCLUDE_DIRECTORIES(${FREETYPE_INCLUDE_DIRS}) + SET(HAVE_FT2BUILD_H 1) + SET(HAVE_LIBFREETYPE 1) + ENDIF(FREETYPE_FOUND) + + IF(ZLIB_FOUND) + INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR}) + SET(HAVE_LIBZ 1) + ENDIF(ZLIB_FOUND) + + IF(VPX_FOUND) + INCLUDE_DIRECTORIES(${VPX_INCLUDE_DIR}) + SET(HAVE_LIBVPX 1) + ENDIF(VPX_FOUND) + + IF(PNG_FOUND) + INCLUDE_DIRECTORIES(${PNG_INCLUDE_DIR}) + SET(HAVE_LIBPNG 1) + ENDIF(PNG_FOUND) + + IF(ICONV_FOUND) + INCLUDE_DIRECTORIES(${ICONV_INCLUDE_DIR}) + SET(HAVE_ICONV 1) + SET(HAVE_ICONV_H 1) + ENDIF(ICONV_FOUND) + + IF(LIQ_FOUND) + INCLUDE_DIRECTORIES(${LIQ_INCLUDE_DIR}) + SET(HAVE_LIBIMAGEQUANT_H 1) + ENDIF(LIQ_FOUND) + + IF(XPM_FOUND) + INCLUDE_DIRECTORIES(${XPM_INCLUDE_DIR}) + SET(HAVE_LIBXPM 1) + ENDIF(XPM_FOUND) + + IF(JPEG_FOUND) + INCLUDE_DIRECTORIES(${JPEG_INCLUDE_DIR}) + SET(HAVE_LIBJPEG 1) + ENDIF(JPEG_FOUND) + + IF(TIFF_FOUND) + INCLUDE_DIRECTORIES(${TIFF_INCLUDE_DIR}) + SET(HAVE_LIBTIFF 1) + ENDIF(TIFF_FOUND) + + IF(FONTCONFIG_FOUND) + INCLUDE_DIRECTORIES(${FONTCONFIG_INCLUDE_DIR}) + SET(HAVE_LIBFONTCONFIG 1) + ELSE (FONTCONFIG_FOUND) + SET(FONTCONFIG_LIBRARY "") + SET(FONTCONFIG_INCLUDE_DIR "") + SET(FONTCONFIG_LIB_DIR "") + ENDIF(FONTCONFIG_FOUND) + + SET(HAVE_CONFIG_H 1) + + ADD_DEFINITIONS(-DHAVE_CONFIG_H) + + CHECK_INCLUDE_FILE("stdint.h" HAVE_STDINT_H) + CHECK_INCLUDE_FILE("inttypes.h" HAVE_INTTYPES_H) + + CONFIGURE_FILE(${GD_SOURCE_DIR}/src/config.h.cmake ${GD_SOURCE_DIR}/src/config.h ESCAPE_QUOTES) + + + set(BUILD_SHARED_LIBS On) + + if (WIN32) + SET(GD_LIB libgd) + ADD_DEFINITIONS( -DWIN32 -D_WIN32 -DMSWIN32 -DBGDWIN32 -DWINVER=0x0500 -D_WIN32_WINNT=0x0500 -D_WIN32_IE=0x0600) + + if(NOT MINGW AND MSVC_VERSION GREATER 1399) + ADD_DEFINITIONS("/D_CRT_SECURE_NO_DEPRECATE") + endif(NOT MINGW AND MSVC_VERSION GREATER 1399) + if (MINGW OR MSYS) + ADD_DEFINITIONS("-mms-bitfields") # -m32 + endif (MINGW OR MSYS) + else (WIN32) + SET(GD_LIB gd) + endif (WIN32) + + SET(GD_LIB_STATIC "${GD_LIB}_static") + + IF(PROFILE) + add_definitions("-pg") + set(CMAKE_EXE_LINKER_FLAGS ${LINK_FLAGS} "-pg") + ENDIF(PROFILE) + + SET(GD_INCLUDE_DIR "${GD_SOURCE_DIR}/src" "${GD_SOURCE_DIR}") + INCLUDE_DIRECTORIES(before ${FONTCONFIG_INCLUDE_DIR}) + + add_subdirectory(src) +endif (USE_EXT_GD) + +add_subdirectory(tests) +add_subdirectory(examples) +add_subdirectory(docs) + +SET(CPACK_PACKAGE_NAME "libgd") +SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "libGD, powerful and easy to use graphic library") +SET(CPACK_PACKAGE_VENDOR "http://www.libgd.org") +SET(CPACK_PACKAGE_VERSION_MAJOR "2") +SET(CPACK_PACKAGE_VERSION_MINOR "1") +SET(CPACK_PACKAGE_VERSION_PATCH "0") + +if(WIN32) + set(CPACK_GENERATOR ZIP) +else(WIN32) + set(CPACK_GENERATOR TGZ) +endif(WIN32) + +IF (ENABLE_LIQ AND LIQ_BUILD) + ADD_DEPENDENCIES(${GD_LIB} libimagequant) + ADD_DEPENDENCIES(${GD_LIB_STATIC} libimagequant) +ENDIF(ENABLE_LIQ AND LIQ_BUILD) + + +INSTALL(FILES docs/INSTALL DESTINATION share/docs) +INSTALL(FILES docs/README.JPN DESTINATION share/docs) +INSTALL(FILES docs/README.CMAKE DESTINATION share/docs) +INSTALL(FILES docs/README.TESTING DESTINATION share/docs) +INSTALL(FILES docs/README.TXT DESTINATION share/docs) + + +INSTALL(FILES examples/arc.c DESTINATION share/docs) +INSTALL(FILES examples/copyrotated.c DESTINATION share/docs) +INSTALL(FILES examples/crop.c DESTINATION share/docs) +INSTALL(FILES examples/flip.c DESTINATION share/docs) +INSTALL(FILES examples/gif.c DESTINATION share/docs) +INSTALL(FILES examples/nnquant.c DESTINATION share/docs) +INSTALL(FILES examples/noIcon.pic DESTINATION share/docs) +INSTALL(FILES examples/noIcon.sgi DESTINATION share/docs) +INSTALL(FILES examples/noIcon.tga DESTINATION share/docs) +INSTALL(FILES examples/noIconAlpha.tga DESTINATION share/docs) +INSTALL(FILES examples/test_crop_threshold.png DESTINATION share/docs) +INSTALL(FILES examples/tgaread.c DESTINATION share/docs) +INSTALL(FILES examples/tiffread.c DESTINATION share/docs) +INSTALL(FILES examples/windows.c DESTINATION share/docs) + + +set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/COPYING") + +set(CPACK_SOURCE_GENERATOR TGZ) +set(CPACK_SOURCE_IGNORE_FILES +"~$" +"\\\\.swp$" +"\\\\.gitignore$" +"^${PROJECT_SOURCE_DIR}/debian/" +"^${PROJECT_SOURCE_DIR}/old/" +"^${PROJECT_SOURCE_DIR}/bld/" +) +install(FILES ${top_level_DOCFILES} DESTINATION ${DOC_DIR}) +INCLUDE(CPack) + diff --git a/Build/source/libs/gd/libgd-2.1.1/CONTRIBUTORS b/Build/source/libs/gd/libgd-2.1.1/CONTRIBUTORS new file mode 100644 index 00000000000..37ae474b6c3 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/CONTRIBUTORS @@ -0,0 +1,26 @@ +chapg +Chris Reuter +Colin Watson +Dimitar Dobrev +edink +Gilles Espinasse +guenter +Kornel Lesiński +kshepherd +lhecking +Marcin Wojdyr +mattias +Mike Frysinger +mloskot +Nathanael Jones +nlopess +Ondřej Surý +Pierre Joye +pornel +Remi Collet +scottmac +tabe +Takeshi Abe +Tim Toohey +tostercx +Vincent Bernat diff --git a/Build/source/libs/gd/libgd-2.1.1/COPYING b/Build/source/libs/gd/libgd-2.1.1/COPYING new file mode 100644 index 00000000000..5e17d03e861 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/COPYING @@ -0,0 +1,53 @@ + + Portions copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, + 2002 by Cold Spring Harbor Laboratory. Funded under Grant + P41-RR02188 by the National Institutes of Health. + + Portions copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 by + Boutell.Com, Inc. + + Portions relating to GD2 format copyright 1999, 2000, 2001, 2002 + Philip Warner. + + Portions relating to PNG copyright 1999, 2000, 2001, 2002 Greg + Roelofs. + + Portions relating to gdttf.c copyright 1999, 2000, 2001, 2002 John + Ellson (ellson@lucent.com). + + Portions relating to gdft.c copyright 2001, 2002 John Ellson + (ellson@lucent.com). + + Portions copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 + Pierre-Alain Joye (pierre@libgd.org). + + Portions relating to JPEG and to color quantization copyright 2000, + 2001, 2002, Doug Becker and copyright (C) 1994, 1995, 1996, 1997, + 1998, 1999, 2000, 2001, 2002, Thomas G. Lane. This software is + based in part on the work of the Independent JPEG Group. See the + file README-JPEG.TXT for more information. + + Portions relating to WBMP copyright 2000, 2001, 2002 Maurice + Szmurlo and Johan Van den Brande. + + Permission has been granted to copy, distribute and modify gd in + any context without fee, including a commercial application, + provided that this notice is present in user-accessible supporting + documentation. + + This does not affect your ownership of the derived work itself, and + the intent is to assure proper credit for the authors of gd, not to + interfere with your productive use of gd. If you have questions, + ask. "Derived works" includes all programs that utilize the + library. Credit must be given in user-accessible documentation. + + This software is provided "AS IS." The copyright holders disclaim + all warranties, either express or implied, including but not + limited to implied warranties of merchantability and fitness for a + particular purpose, with respect to this code and accompanying + documentation. + + Although their code does not appear in gd, the authors wish to thank + David Koblas, David Rowley, and Hutchison Avenue Software Corporation + for their prior contributions. + diff --git a/Build/source/libs/gd/libgd-2.1.1/ChangeLog b/Build/source/libs/gd/libgd-2.1.1/ChangeLog new file mode 100644 index 00000000000..8668226ee13 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/ChangeLog @@ -0,0 +1,317 @@ +be907e0 fix indent (Pierre Joye) +999b5d2 add sanity check and fix leak on exit (Pierre Joye) +1424dd6 free path on error (Pierre Joye) +13d87a6 free im on error (Pierre Joye) +2a40315 update changelog (Pierre Joye) +5c562ec Add thumbs.bat and thumbs.sh to Makefile.am (Nathanael Jones) +bc372f2 Merge branch 'master' into rebase-1-for-2015 (Nathanael Jones) +a247407 Use sprintf instead of snprintf to be C89 compliant. (Nathanael Jones) +0324316 Remove uneeded includes introduced in earlier version-local commits. (Nathanael Jones) +4d54513 Exposed all missing format-independent members in the C++ wrapper. (Nathanael Jones) +c7bf379 Update gdpp.* to use HAVE_LIBPNG vs HAVE_PNG, etc.- should honor the same feature support flags as the rest of gd, (Nathanael Jones) +40c6129 Normalize static lib name to libgd.a on *nix and libgd_static.lib on windows. (Nathanael Jones) +7c2b071 Replace windows MSVC makefile; update msys iconv path. (Nathanael Jones) +07c3fde Drop -m32 definition on MINGW; prevents a 64-bit build from occurring. (Nathanael Jones) +37f5925 Skip bug00132 - failing because test data is out if date (we think). (Nathanael Jones) +f085a2e When both CPP_SHARP and _WIN32 are defined, do not enable thread safety. (Nathanael Jones) +e81ff90 Export C++ wrapper clases. Change two Gd() functions of the C++ wrapper to return values when the underlying C calls do. (Nathanael Jones) +56f79f3 C89 compat; define vars at top of function (Nathanael Jones) +b52b9c5 Upgrade to long-syntax CMAKE add_test command to improve cross-platform compatibility. (Nathanael Jones) +e8a1a46 free coeffs (Pierre Joye) +5f7c099 free allocated palette on error (Pierre Joye) +7b49862 fix im leaked on error (Pierre Joye) +4faf926 just reduce static analyzer noise (Pierre Joye) +2a09086 free tc_cache and path on error (leak) (Pierre Joye) +09e954b Thumbs: add osx settings for travis (tostercx) +4af76c9 fix comment (Remi Collet) +3c0d220 Fix possible infinite loop (php bug report #68713) - make code more legible (yy>=yy-1 seems ugly) - fix mem leak, always free src->tpixels (Remi Collet) +7a8e6b8 Thumbs: use rsync -u on osx as it doesn't have cp -u (tostercx) +eb9d7d1 Thumbs: Remove cp -u usage (Nathanael Jones) +c9e458b add read-only test images to tarball (Remi Collet) +3169371 use / in image patch (Remi Collet) +81e9a99 move overflow test outside the loop for perf (Remi Collet) +47eb44b Fix possible buffer read overflow detected by -fsanitize=address, thanks to Jan Bee (Remi Collet) +5fe6837 squash test commits; add deps from nuget; fix bindings (tostercx) +679fd78 pack compressed dll vers; build bindings (tostercx) +0c3b914 fix mingw if blocks (tostercx) +84319d1 replace slashes with backslashes for appveyor/cmd (tostercx) +c954881 add build targets for gnu with thumbs (tostercx) +18c51e6 fix tiff targets (tostercx) +5f99611 fix dll_name not set before usage (tostercx) +c447d68 fetch nasm (tostercx) +7ba81f0 add thumbs (tostercx) +4865cdb rename libs correctly as soon as they're copied (tostercx) +bf51c4e fix tbsd_*_built flags not being set (tostercx) +f3deb6b add basic msvc thumbs (tostercx) +39fd5ce Exposed all missing format-independent members in the C++ wrapper. (Dimitar Dobrev) +2d74b00 update lib switching macros (tostercx) +d5527e7 push config.h (tostercx) +5828f7e Use ifdefs around keyword redefinitions (Nathanael Jones) +d3fb9c3 update appveyor project url (tostercx) +6db34b7 Merged in nathanaeljones/gd-libgd/test-message-improvements (pull request #22) (Nathanael Jones) +d1a6768 Merged in nathanaeljones/gd-libgd/add-osx-boostrap-support (pull request #21) - bootstrap.sh now offers build tips on OS X and defaults to glibtoolize (Nathanael Jones) +31619ab Merged in nathanaeljones/gd-libgd/shut-up-automake (pull request #23) Silence automake 1.14 warnings (Nathanael Jones) +7eb9462 Merged in nathanaeljones/gd-libgd/cmake-iconv (pull request #24) (Nathanael Jones) +dedf03f Merged in nathanaeljones/gd-libgd/msvc-fix-keyword-macros (pull request #25) (Nathanael Jones) +c4809ae Changed two functions of the C++ wrapper to return values when the underlying C calls do. (Dimitar Dobrev) +433b04a set msvc output to minimal (tostercx) +daa7613 move drone build script to file (tostercx) +82550ca add drone badge (tostercx) +6ea31fb reset build type (tostercx) +47eaee1 test CMAKE_BULD_TYPE (tostercx) +e4fbb28 test CMAKE_BULD_TYPE (tostercx) +8e18552 push uncompressed dlls as artifacts (tostercx) +0bcb5e3 push uncompressed dlls as artifacts (tostercx) +5d09526 test dgn w64 (tostercx) +e3fe7e4 warn inline (tostercx) +adc3b7c test w64-32 (tostercx) +55f9066 inline test 3 (tostercx) +12898fe inline test 2 (tostercx) +8864390 inline test (tostercx) +0cd926f Exported all classes from the C++ binding of libgd. (Nathanael Jones) +c8711e7 fetch binding gen from master (tostercx) +23b5f11 test 32bit msvc bindings (tostercx) +98d1a1a update binding artifact handling (tostercx) +6be49c8 test msvc x64 bindings 4 (tostercx) +97c2846 test msvc x64 bindings 3 (tostercx) +eee663c test msvc x64 bindings 2 (tostercx) +a7ce8bb test msvc x64 bindings (tostercx) +12a6fbc scrap ramdisks (tostercx) +1f07497 ramdisk test 3 (tostercx) +398a82c ramdisk test 2 (tostercx) +c6cd0d8 ramdisk test (tostercx) +ae8a7e5 imdisk test 7 (tostercx) +3a178fd imdisk test 6 (tostercx) +5d5eb2a imdisk test 6 (tostercx) +bfdc673 imdisk test 5 (tostercx) +1855563 imdisk test 5 (tostercx) +084e2e2 imdisk test 4 (tostercx) +bbad6a7 imdisk test 3 (tostercx) +9d3bd38 imdisk test 2 (tostercx) +ff7ace5 Merge branch 'master' of https://github.com/imazen/gd-libgd (tostercx) +e78df6a imdisk test (tostercx) +f15ea0e Msbuild logging: Fix block scope error (Nathanael Jones) +3a7334c Msbuild now logs to file and uploads as artifact (Nathanael Jones) +c0ce1fa Enable verbose msbuild output temporarily (Nathanael Jones) +b70fd99 fix unix static name (tostercx) +b217d22 update nuget package names; add version # (tostercx) +724869d update test macro usage (tostercx) +560aa9b fix ps syntax errors (tostercx) +dce1809 configure files only if building bindings (tostercx) +e023800 test min=1 (tostercx) +668ef42 test min=0 (tostercx) +c28d572 quote function (tostercx) +cd9ae09 test test switching macros (tostercx) +c9b0fec add gdsharp .cs files to artifact (tostercx) +c19f2e0 remove SET spaces (tostercx) +3e88692 fix if spacing (tostercx) +9208848 test min flag (tostercx) +fef130e mingw test - noft; wtiff (tostercx) +8fae7df test mingw no tiff (tostercx) +bef860f mingw test build (tostercx) +841f3cd fix msvc static lib name; test mingw no-rtti (tostercx) +31552f5 build all (tostercx) +071963b fix if block (tostercx) +71f8aaf remove original dll on pack (tostercx) +b7ac813 minimal build (tostercx) +487ee4c re-enable packing (tostercx) +8e4ea0e test ps spacing (tostercx) +3ef2235 disable upx (tostercx) +918d603 update library names (tostercx) +bfff81d update library names (tostercx) +daa782e upx test 3 (tostercx) +5fc0ca3 upx test 2 (tostercx) +4fba094 add upx; fix cmake_cmd (tostercx) +015be62 spring cleaning (tostercx) +09daf1d re-fix if block (tostercx) +338c39b fix mingw freetype static link (tostercx) +335fd04 fix tiff static link (tostercx) +397029a fix if block (tostercx) +c16ccd1 fix freetype static links (tostercx) +6c3617a add appveyor badge (tostercx) +b6b0249 push nunit result xml as artifact (tostercx) +d87b394 disable iconv (tostercx) +fb10cf1 fix dll dir for bindings (tostercx) +61e8d53 simplify build script (tostercx) +b6a6ba6 fix static link to iconv for mingw builds (tostercx) +f8d2a36 fix mingw static links (tostercx) +ff2eb8a fix msvc link to static jpeg (tostercx) +1d75d52 remove inline flags; fetch deps from subbuilds (tostercx) +b0167e9 keep inline functions (tostercx) +6d3ab8d fix mingw dir; build only mingw (tostercx) +4d88ae7 scrap .vhd mount; update compiler blob location (tostercx) +1f7d33b test mounted mingww64 (tostercx) +bd4cebd fix bloated freetype (tostercx) +ade007d Support MSVC++ 2013 and higher: define _ALLOW_KEYWORD_MACROS, inline, strcasecmp, snprintf. (Nathanael Jones) +f82b371 Add libiconv support to CMake files (Nathanael Jones) +10ffb33 Silence automake 1.14 warnings ("source file is in a subdirectory, but option subdir-objects is disabled"). (Nathanael Jones) +90c3799 Add gdTestAssertMsg(condition, formatmessage, variables) to support detailed failure messages. Improve error reporting and diagnostics in gdimagefile test. Fix 'max' definition conflict on some compilers. (Nathanael Jones) +7f1d183 bootstrap.sh now offers build tips on OS X and defaults to glibtoolize (Nathanael Jones) +444c760 update mingw crt static link command (tostercx) +0b10bb8 exclude failing binding test; build all (tostercx) +f05791c static link msvc runtime (tostercx) +4f8e411 fix elseif block (tostercx) +7dc864c static link mingw compiler deps (tostercx) +c38ad3c update repositories (tostercx) +64b843b Merge pull request #5 from tostercx/master (tostercx) +292124c squash everything (tostercx) +8d63a96 Merge pull request #4 from tostercx/master (Nathanael Jones) +344267f fix testing env detection and directory (tostercx) +9664951 fix tests not executing (tostercx) +701507b fix x64 cross compiles (tostercx) +33dff1f not needed anymore (tostercx) +c1bcfcd not needed anymore (tostercx) +9546428 fix platform letter case (tostercx) +4d74480 fix gdtest not rebuilding (tostercx) +4fac5f7 remove mkdir error messages (tostercx) +6e7128a Prevent CppSharp parsing error (Nathanael Jones) +8e8c0f9 Get gdnametest passing on windows (Nathanael Jones) +300b6ff Fix gdnametest on *nix (Nathanael Jones) +6c4ffe7 Improve error messages in gdnametest. (Nathanael Jones) +ddbf021 Drop strcasecmp implementation. Only define 'inline' on msvc builds. (Nathanael Jones) +42e5fa7 Merge remote-tracking branch 'origin/master' (Nathanael Jones) +e30293d Add a readme for building on windows. (Nathanael Jones) +681992a Remove src/config.h and src/gd.h from .gitignore. Sheesh. (Nathanael Jones) +235c5b0 Merge pull request #3 from tostercx/master (Nathanael Jones) +0eb3b05 fix rebuilds failing (tostercx) +dab8734 fix mkdir failing on appveyor (tostercx) +0356ea9 fix mkdir failing on appveyor (tostercx) +96408de fix mkdir (tostercx) +073197d fix dir making (tostercx) +2e1d22e fix makefile always rebuilding (tostercx) +25b31be add cleanup, .gitnore build directories and deps, partially fix always rebuilding (tostercx) +7f735f6 Merged in nathanaeljones/gd-libgd/nathanaeljones/restore-support-for-alphablendingflag-va-1409782287517 (pull request #20) (Pierre Joye) +08eb6ee Restore support for alphaBlendingFlag value gdEffectAlphaBlend (Nathanael Jones) +e3ff6ec C89 compat (tostercx) +e52ed5e Merge pull request #2 from tostercx/master (Nathanael Jones) +6cc63f2 fix platorm reports in test (tostercx) +68a8dc0 updated windows makefile and test execution (tostercx) +8e7df78 Fix syntax error in Makefile.vc (missing line continuations) (Nathanael Jones) +71ab3d8 Fix space/tab mix in Makefile.vc; enable vectorization reporting. (Nathanael Jones) +911046d Comment out unused compilation vars; ensure (_)WIN32 is set, enable speed optimizations via /O2 (Nathanael Jones) +749b33e Improve error reporting in gdimagefile test. Add gdTestAssertMsg(condition, message, variables) to support detailed failure messages. (Nathanael Jones) +db88704 Restore support for alphaBlendingFlag value gdEffectAlphaBlend. (9 unit tests pass again). (Nathanael Jones) +dc8bb49 Only omit the 'max' macro if it is already present (this may break windows, let's see) (Nathanael Jones) +b0b140f Drop 7zip installation step, should already be installed on AppVeyor by default. (Nathanael Jones) +bcf7cb4 Switch dependency repository back, and use a named branch now for compatibility. (Nathanael Jones) +043dfa8 Merge pull request #1 from tostercx/master (Nathanael Jones) +12ab27b add notes (tostercx) +b710274 remove old makefiles (tostercx) +dd870dc consolidate makefiles to windows/makefile.vc (tostercx) +c114d89 consolidate makefiles to windows/makefile.vc (tostercx) +720f82b add static lib to artifacts, generate test config in makefile (tostercx) +c088f28 add static lib to artifacts, generate test config in makefile (tostercx) +0db988e add static lib to artifacts, generate test config in kaefile (tostercx) +1ce2b19 fix overwriting LIB env var (tostercx) +e0475cc debug iconv tmp fix (tostercx) +a3ee395 re-fix mkdir (tostercx) +5abb901 fix mkdir (tostercx) +35888c5 added making static libgd (tostercx) +701bc63 switch to libjpeg-turbo (tostercx) +d74fa37 fetch deps from imazen/gd-win-dependencies (tostercx) +23cbea2 Add AppVeyor files provided by TosterCx (Nathanael Jones) +af9ca1d Simplify makefile and add static lib generation. (Nathanael Jones) +ce5f060 Simplify Makefile.vc (Nathanael Jones) +ab31a6d Build inside Release_GD (Nathanael Jones) +ee308e1 Rename Makefile.gd and add some notes (Nathanael Jones) +d8987f5 Added strcasecmp implementation, now creates a .dll (Nathanael Jones) +09006c4 Get makefile almost working (Nathanael Jones) +2fdf3ad Start work on nmake makefile (Nathanael Jones) +0eb8429 Changed path to libiconv in msys Makefile. (Nathanael Jones) +5aee678 Merged from the upstream. (Nathanael Jones) +31ff666 Merged in ttoohey/gd-libgd/layout-effect (pull request #18) (Ondřej Surý) +33c05c1 Merged in ttoohey/gd-libgd/bugfix/font_path_overrun (pull request #19) (Ondřej Surý) +463c3bd CVE-2014-2497, NULL pointer dereference, fix #126 (Remi Collet) +f01ade7 Remove wrong license headers. Based on http://www.paulbourke.net/dataformats/tga/ (Pierre Joye) +354409b Fix buffer overrun from long font search path (Tim Toohey) +01dccbd add tests for layer effects (Tim Toohey) +b39f92b Add overlay and multiply effects to gdImageSetPixel (Tim Toohey) +4b86e06 Fix artefact in gdImageScale using GD_BILINEAR_FIXED (Remi Collet) +1de3b80 new example "resize" (Remi Collet) +5b42b11 Fix gdImageSetInterpolationMethod with GD_DEFAULT (Remi Collet) +2d5dc2e MSys Makefile now statically links libgd.dll to libiconv. (Chris Reuter) +01104a2 MSys Makefile fix (Chris Reuter) +7a8e8b2 Bug fix: GD DLL rename hadn't been propagated everywhere. (Chris Reuter) +6b94f66 Minor enhancements to the MinGW+Msys build scripts. (Chris Reuter) +339b17a Updated the MSys build files. (Chris Reuter) +0cb34fd Got gd_filename.c to work correctly under Windows. (Chris Reuter) +74ad18c Updated .gitignore. (Chris Reuter) +0da2258 Added TIFF to the list of skipped image formats in gdnametest.c (Chris Reuter) +0afe34d Merge branch 'master' of https://bitbucket.org/libgd/gd-libgd (Chris Reuter) +275ac17 Started importing the old manual into Naturaldocs comments. (Chris Reuter) +3b2caf6 Added function 'gdImageGetInterpolationMethod()'. (Chris Reuter) +592e232 Merge branch 'master' of https://bitbucket.org/libgd/gd-libgd (Chris Reuter) +00cd958 Added gdnametest and gdCopyBlurred to .gitignore. (Chris Reuter) +4761a7e Added gdnametest and gdCopyBlurred to .gitignore. (Chris Reuter) +c9d2f89 Added gdImageFile(), gdImageCreateFromFile() and gdSupportsFileType(). (Chris Reuter) +9eb3951 Added gdImageFile(), gdImageCreateFromFile() and gdSupportsFileType(). (Chris Reuter) +e054be7 Small code cleanup. (Chris Reuter) +3cb508f Small code cleanup. (Chris Reuter) +9933000 Merge branch 'master' of https://bitbucket.org/libgd/gd-libgd (Chris Reuter) +b20cdef Added a test case for gdImageCopyGaussianBlurred(). (Chris Reuter) +6febd90 Added a new Gaussian blur function. (Chris Reuter) +3c43f07 Merge branch 'master' of https://bitbucket.org/libgd/gd-libgd (Chris Reuter) +d525680 Bug fix: gdImageScale() was sometimes messing up transparency. (Chris Reuter) +b505465 Merge remote-tracking branch 'upstream/master' (Chris Reuter) +549addc Added .gitignore lines to exclude naturaldocs by-products. (Chris Reuter) +bb1d4a0 Added documention for gdImageCreate() and type gdImage. (Chris Reuter) +3c1202e Added beginnings of an updated manual (Chris Reuter) +7060f5e Added another Makefile. (Chris Reuter) +769fb15 Added another Makefile. (Chris Reuter) +3f8931d Bug fix: tests didn't (always) return a valid status. (Chris Reuter) +0dfd45c Bug fix: tests didn't (always) return a valid status. (Chris Reuter) +f316c8a Removed bash-ism from bootstrap.sh. (Not /bin/sh are bash, even these days.) (Chris Reuter) +6cb7f9f Merge branch 'master' of github.com:imazen-discovery/gd-libgd (Chris Reuter) +0adaf8a Merge branch 'master' of https://bitbucket.org/libgd/gd-libgd (Chris Reuter) +d21db28 Merge remote-tracking branch 'refs/remotes/origin/master' (Nathanael Jones) +68d38a8 bootstrap.sh now offers build tips on OS X and defaults to glibtoolize (Nathanael Jones) +9812cc4 Merge branch 'master' of https://bitbucket.org/suetanvil/gd-libgd. (Chris Reuter) +506e57a Merged libgd/gd-libgd into master (Chris Reuter) +16ccce6 Fixed a comment. (Chris Reuter) +e82b084 Added new files to CMakeLists.txt. (Chris Reuter) +8cdb109 Updated Netware makefile (Chris Reuter) +784ffdd Test case for new version code. (Chris Reuter) +4378b8d gd.h now holds the canonical version number. (Chris Reuter) +3c96ad1 Keep automake from complaining "automake: but option 'subdir-objects' is disabled" (Nathanael Jones) +5b7f746 Merged libgd/gd-libgd into master (Chris Reuter) +3766620 Merge branch 'master' of https://bitbucket.org/libgd/gd-libgd (Chris Reuter) +3884557 Merged in suetanvil/gd-libgd/scale-palette-image-bug (pull request #16) (Chris Reuter) +1a92b2e Merged in suetanvil/gd-libgd/interp-precision (pull request #15) (Chris Reuter) +723ea52 Fix for Issue #97: segfaults when scaling a non-truecolor image (Chris Reuter) +f321961 Added test case to exercise all of the gdImageScale() modes. (Chris Reuter) +5586a1e Merged libgd/gd-libgd into master (Chris Reuter) +948bb0a Higher precision in scaling. (Chris Reuter) +3f713da Higher precision in scaling. (Chris Reuter) +1c6ee56 More dead code removal. (Chris Reuter) +241ada6 Removed some dead code. (Chris Reuter) +916d00c Merged in suetanvil/gd-libgd/suetanvil-scale-code-cleanup (pull request #14) (Pierre Joye) +0510b4f Merged in suetanvil/gd-libgd/suetanvil-dead-code-removal (pull request #13) (Pierre Joye) +2ade818 Merge branch 'private-scale-axis-merge-rebased' (Chris Reuter) +546b274 Bug fix: #92: Bicubic scaling leaves the rightmost and bottom rows black (Chris Reuter) +16ed1a9 Added a test case for gdImageScaleTwoPass(). (Chris Reuter) +65fce84 Improved testing code (Chris Reuter) +be3c8cb Cleaned up floating-point rescaling code. (Chris Reuter) +0d13658 More dead code removal. (Chris Reuter) +5ce14ef Removed some dead code. (Chris Reuter) +70a4070 Merge branch 'master' of https://bitbucket.org/suetanvil/gd-libgd (Chris Reuter) +08fdff6 Merged libgd/gd-libgd into master (Chris Reuter) +6db2828 Merge remote-tracking branch 'remotes/bitbucket-repo/suetanvil' (Chris Reuter) +3c5c639 Merged in suetanvil/gd-libgd/suetanvil (pull request #12) (Pierre Joye) +4f65a3e Fixed memory overrun bug in gdImageScaleTwoPass (Chris Reuter) +3e76d30 Merged libgd/gd-libgd into master (Chris Reuter) +de7acbf Merged in suetanvil/gd-libgd (pull request #11) (Pierre Joye) +4c70f57 Fix #86: gdImageScale segfaults with most interpolation types (Chris Reuter) +6d1275d Fix bug #86 (segfaults on gdImageScale with most interpolation modes). (Chris Reuter) +2a862b2 Undo previous change to make a cleaner changeset. (Chris Reuter) +4a90e3f Fixed bug #86. https://bitbucket.org/libgd/gd-libgd/issue/86/gdimagescale-segfaults-with-most (Chris Reuter) +d47c718 Merge branch '2.1.0-stable' into bicubic-fixed-perf (Chris Reuter) +fda0b29 Added a function to retrieve the interpolation mode ID. (Chris Reuter) +fb93646 Added the latest manual I could find. (Chris Reuter) +a0be11f Added new README.md prior to importing into GitHub. (Chris Reuter) +a0f58c6 fix #81, cmake_minimum_required must be the 1st line in 2.8+ (Pierre Joye) +54f8019 GD_EXTRA_VERSION and GD_VERSION_STRING needs quotes (Courtesy of Marc Deslauriers) (Ondřej Surý) +dfea094 Add INSTALL notes for Solaris conflicting iconv.h headers (fixes #76) (Ondřej Surý) +37689ef ignore generated gd.h header (Ondřej Surý) +5b917b4 Merged in fix-version-in-gd.h (pull request #9) (Ondřej Surý) +f597bd4 Don't append dash when GDLIB_EXTRA is empty (Ondřej Surý) +f47a1df Create gd.h from gd.h.in to properly include current library version (Ondřej Surý)
\ No newline at end of file diff --git a/Build/source/libs/gd/libgd-2.1.1/Makefile.am b/Build/source/libs/gd/libgd-2.1.1/Makefile.am new file mode 100644 index 00000000000..17c5b0537e7 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/Makefile.am @@ -0,0 +1,3 @@ +ACLOCAL_AMFLAGS = -I m4 +SUBDIRS = src config tests +EXTRA_DIST = test docs examples windows VMS cmake netware bootstrap.sh CMakeLists.txt thumbs.bat thumbs.sh CONTRIBUTORS README diff --git a/Build/source/libs/gd/libgd-2.1.1/NEWS b/Build/source/libs/gd/libgd-2.1.1/NEWS new file mode 100644 index 00000000000..8bf38434add --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/NEWS @@ -0,0 +1,109 @@ +'GD NEWS +||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| +GD HEAD +169, gdColorMapLookup() answers the RGB values according to given color map + (Takeshi Abe) +176, Added support of variable resolution by Alan Boudreault (Takeshi Abe) +184, new filter gdImagePixelate() by Kalle Sommer Nielsen (Takeshi Abe) + +GD 2.0.36 (2007-11-xx) +145, Fixed leak in gdImageCopyResized (Patch by Brent Bottles) + 81, Fixed gdImageCopy with true color image, the transparent color was ignored + (Pierre, Mark Fisher) + 88, Fixed support of PNG grayscale image with alpha channel (Pierre) + 95, Added Netware builds script (Guenter) + 97, ease the creation of regexp to match symbols/functions in the sources + (Guenter) +100, spurious horizontal line drawn by gdImageFilledPolygon (Takeshi Abe) +101, _gdCreateFromFile() can crash if gdImageCreate fails (Mattias Bengtsson) +105, gdImageCreateFrom*Ptr() can crash if gdNewDynamicCtxEx() fails (Mattias) +106, gdImageRectangle draws 1x1 rectangles as 1x3 rectangles (Pierre) +109, Possible integer overflow in gdImageFill() (Mattias Bengtsson) +111, Optimization for single pixel line not in correct order (Mattias) +112, gdImageColorDeallocate can write outside buffer (Mattias Bengtsson) +113, gdImageColorTransparent can write outside buffer (Mattias Bengtsson) +127, gdImageWBMPCtx can crash when createwbmp fails (Scott) +132, Fixed decoding of the html entity ϑ (Thomas Bonfort, Pierre) +133, Fixed configure script ignoring --with-png=DIR option (Scott) +166, Fixed handling 3-digit RGB and transparent color in XPM (Takeshi Abe) +173, Fixed the memory management in font_path() of gdft.c (Takeshi Abe) +174, Fixed that font_path() in gdft.c breaks reentrancy (Takeshi Abe) +180, Added a Makefile entry for tests/xpm (Takeshi Abe) +181, Fixed gd_gif_out.c to enable proper interlace +185, Fixed memory leaks in gdImageCreateFromXpm() (Takeshi Abe) +186, Fixed tiling true colour with palette image (Marko Vukovic, Takeshi Abe) +193, Fixed gdImagePng() with no color allocated (Martin McNickle, Takeshi Abe) +196, Fixed a memory leak in newDynamic() (Steve Fossen) +198, Fixed useFontConfig() to work as documented (Mojca Miklavec, Ethan Merritt) + +GD 2.0.35 (2007-06-21) +41, Fix valgrind error in gdImageFillTiled (Nuno Lopes) +45, Add missing custom cmake macros (required for the tests suite) +51, Avoid signature buffer copy in gd_gif_c (Nuno Lopes) +48, Race condition in gdImageStringFTEx (Antony Dogval, Pierre + Scott MacVicar) +52, Reading GIF images is not thread safe (static usage in private + functions) (Roman Nemecek, Nuno Lopes, Pierre) +60, GIF Local palette is read twice +66, GIF, Use local frame dimension when possible instead of the + logical screen size (Pierre) +68, OpenVMS build support, see VMS/README.VMS for the details + (Alexey Chupahin) +70, GIF, do not try to use the global colmap if it does not exist + (Nuno Lopes, Pierre) +72, gdImageAALine draws axis lines with two pixels width (Pierre) +73, TTF usage doesn't work properly on Netware (Guenter Knauf, Scott MacVicar) +74, gdImageArc CPU usage with large angles (Pierre) +78, gdImageFilledRectangle regression fixed when used with reversed edges + (Pierre) +86, Possible infinite loop in libgd/gd_png.c, flaw found by Xavier Roche + (Pierre) +87, Fixed segfault when an invalid color index is present in a GIF + image data, reported by Elliot <wccode at gmail dot com> (Pierre) +89, Possible integer overflow in gdImageCreateTrueColor (Pierre) +94, gdImageCreateXbm can crash if gdImageCreate fails (Pierre) + +GD 2.0.34 (2007-02-07) + 3, Initialize variables in tweenColorTest, fix cache + 4, gdImageFill, multiple segfaults with patterns or invalid arguments + 5, gdImageRectangle draws corners twice + 6, GIF Output does use the transparent color with truecolor images + 7, Multiple security issues in GIF loader + 8, gdIimageCopy doen't use the alpha channel + 9, Add autogen and and misc configure/makefile (Lars Hecking) +10, gdImageFilledEllipse does not respect transparency +11, gdImageCreateFromPng* crashes with empty file +12, gdImageCreateFromPngCrx, initialize the signature buffer not the + infile +13, leak in jinit_2pass_quantizer (gd_topal.c) +14, Added santiy checks for possible memory allocation errors +15, gdImageCreatePaletteFromTrueColor, later color allocations overwrite + the palette colors (Rob Leslie) +16, Obscure error on Sun's compiler in entities.tcl + (John Ellson/Graphviz) +17, gdImageCreate, invalid gdFree call when overflow2 fails +18, HWB_Diff, invalid usage of abs instead of fabs + (Nick Atty) +19, Fixed gdImageCopyMergeGray when used with a true color image +20, transparency preservation in gdImageCopyRotated +21, Out of range checks in gdImageSetAAPixelColor +22, gdFontCacheSetup does not stop on error +23, Errors when gdImageStringFTEx is called with an empty string + (Kevin Scaldeferri) +24, gdft.c, uninitialized variable "charmap" and avoid divide-by-zero + (John Ellson/Graphviz) +25, DISABLE_THREADS to permit disabling of thread support + (John Ellson/Graphviz) +26, dynamicGetbuf, sourceGetbuf must return 0 for errors and EOF +27, gdSeek declaration is wrong +29, Windows native makefile (Edin KadribaÅ¡ić) +30, restores the ability to recognize and handle a font with + Adobe-specific character encoding. Added gdFTEX_Adobe_Custom. +31, Shared library support on cygwin (Dr. Volker Zell) +32, Pattern-fill works incorrectly if tile is created via + gdImageCreateTruecolor (Ethan Merritt) +33, malformed PNG image crashes (CRC error) +34, reading some gif images creates infinite loop +36, gdImageFillToBorder crashes when used with alpha +40, possible Buffer overflow in the gdImageStringFTEx function + in gdft.c (CVE-2007-0455) (Kees Cook) diff --git a/Build/source/libs/gd/libgd-2.1.1/README b/Build/source/libs/gd/libgd-2.1.1/README new file mode 100644 index 00000000000..457b9c1f027 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/README @@ -0,0 +1,10 @@ +GD is an open source code library for the dynamic creation of images by programmers. + +GD is written in C, and "wrappers" are available for Perl, PHP and other languages. GD creates PNG, +JPEG, GIF, WebP, XPM, BMP images, among other formats. GD is commonly used to generate charts, +graphics, thumbnails, and most anything else, on the fly. While not restricted to use on the web. + +The most common applications of GD involve website development. + +The library was originally developped by Thomas Boutell and is now maintained by many contributors (see the CONTRIBUTORS file) +under the umbrella of PHP.net. diff --git a/Build/source/libs/gd/libgd-2.1.1/VMS/CONFIGURE.COM b/Build/source/libs/gd/libgd-2.1.1/VMS/CONFIGURE.COM new file mode 100644 index 00000000000..a2e42c5b223 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/VMS/CONFIGURE.COM @@ -0,0 +1,1343 @@ +$! (c) Alexey Chupahin 18-APR-2006, 15-DEC-2007 +$! OpenVMS 8.2 Alpha DEC 2000 model 300 +$! OpenVMS 8.3 Itanium rx1620 +$! GNU +$! +$! +$DEF SYS$ERROR _NL0: +$ SET NOON +$WRITE SYS$OUTPUT " " +$WRITE SYS$OUTPUT "Configuring GD library for OpenVMS" +$WRITE SYS$OUTPUT "(c) Alexey Chupahin " +$! Checking architecture +$! Checking architecture +$ IF F$GETSYI("ARCH_TYPE").EQ.1 THEN CPU = "VAX" +$ IF F$GETSYI("ARCH_TYPE").EQ.2 THEN CPU = "Alpha" +$ IF F$GETSYI("ARCH_TYPE").EQ.3 THEN CPU = "I64" +$ OS = F$GETSYI("VERSION") +$WRITE SYS$OUTPUT "Checking architecture ... ", CPU +$WRITE SYS$OUTPUT "Checking OS ... OpenVMS ",OS +$SHARED=0 +$IF ( (CPU.EQS."Alpha").OR.(CPU.EQS."I64") ) +$ THEN +$ SHARED=64 +$ ELSE +$ SHARED=32 +$ENDIF +$DECC = F$SEARCH("SYS$SYSTEM:DECC$COMPILER.EXE") .NES. "" +$IF (DECC) THEN $WRITE SYS$OUTPUT "Compiler ... DEC C" +$IF (.NOT. DECC) THEN $WRITE SYS$OUTPUT "BAD compiler" GOTO EXIT +$MMS = F$SEARCH("SYS$SYSTEM:MMS.EXE") .NES. "" +$MMK = F$TYPE(MMK) +$IF (MMS .OR. MMK.NES."") THEN GOTO TEST_LIBRARIES +$WRITE SYS$OUTPUT "Please install MMS from DECSET or MMK" +$! I cant find any make tool +$GOTO EXIT +$! +$! +$TEST_LIBRARIES: +$! Setting as MAKE utility one of MMS or MMK. I prefer MMS. +$IF (MMK.NES."") THEN MAKE="MMK/IGN=WAR" +$IF (MMS) THEN MAKE="MMS/IGN=WAR" +$WRITE SYS$OUTPUT "Checking build utility ... ''MAKE'" +$WRITE SYS$OUTPUT " " +$! +$IF (P1.EQS."STATIC") .OR. (P1.EQS."static") +$ THEN +$ WRITE SYS$OUTPUT "Configuring for static only" +$ SHARED=0 +$ENDIF +$! +$! Is it package root directory? If no, go to [-] +$ IF (F$SEARCH("[]VMS.DIR").EQS."") .AND. (F$SEARCH("[]vms.dir").EQS."") +$ THEN +$ SET DEF [-] +$ ENDIF +$! +$!Checking for iconv +$! +$ DEFINE SYS$OUTPUT _NLA0: +$ CC/OBJECT=TEST.OBJ SYS$INPUT + #include <iconv.h> + int main() + { + iconv_t cd; + cd = iconv_open ((const char *)0, (const char *)0); + } +$TMP = $STATUS +$DEAS SYS$OUTPUT +$IF (TMP .NE. %X10B90001) +$ THEN +$ HAVE_ICONV=0 +$ENDIF +$DEFINE SYS$OUTPUT _NLA0: +$LINK/EXE=TEST TEST +$TMP = $STATUS +$!WRITE SYS$OUTPUT TMP +$IF (TMP .NE. %X10000001) +$ THEN +$ HAVE_ICONV=0 +$ ELSE +$ HAVE_ICONV=1 +$ENDIF +$DEAS SYS$OUTPUT +$IF (HAVE_ICONV.EQ.1) +$ THEN +$ WRITE SYS$OUTPUT "Checking for system iconv library... Yes" +$ ELSE +$ WRITE SYS$OUTPUT "Checking for system iconv library... No" +$ENDIF +$! +$!"Checking for correct zlib library " +$ ZLIB_STATIC=0 +$ DEFINE SYS$OUTPUT _NLA0: +$ CC/OBJECT=TEST.OBJ/INCLUDE=(ZLIB) SYS$INPUT + #include <stdlib.h> + #include <stdio.h> + #include <zlib.h> + int main() + { + printf("checking version zlib: %s\n",zlibVersion()); + } +$TMP = $STATUS +$DEAS SYS$OUTPUT +$IF (TMP .NE. %X10B90001) +$ THEN +$ HAVE_ZLIB=0 +$ GOTO NEXT1 +$ENDIF +$DEFINE SYS$OUTPUT _NLA0: +$!Testing for shared ZLIB +$COPY SYS$INPUT [.SRC]OPT.OPT +SYS$SHARE:LIBZSHR/SHARE +$LINK/EXE=TEST TEST,[.SRC]OPT/OPT +$TMP = $STATUS +$DEL [.SRC]OPT.OPT;* +$!WRITE SYS$OUTPUT TMP +$IF (TMP .NE. %X10000001) +$ THEN +$ LINK/EXE=TEST TEST,ZLIB:LIBZ/LIB +$ TMP = $STATUS +$ IF (TMP .NE. %X10000001) +$ THEN +$ HAVE_ZLIB=0 +$ ELSE +$ HAVE_ZLIB=1 +$ ZLIB_STATIC=1 +$ ENDIF +$ ELSE +$ HAVE_ZLIB=1 +$ENDIF +$NEXT1: +$DEAS SYS$OUTPUT +$IF (HAVE_ZLIB.EQ.1) +$ THEN +$ WRITE SYS$OUTPUT "Checking for correct zlib library ... Yes" +$ ELSE +$ WRITE SYS$OUTPUT "Checking for correct zlib library ... No" +$ WRITE SYS$OUTPUT "This is fatal. Please download and install good library from fafner.dyndns.org/~alexey/libsdl/public.html" +$ GOTO EXIT +$ENDIF +$RUN TEST +$! +$! +$FREETYPE_STATIC=0 +$!"Checking for correct Freetype2 library" +$ DEFINE SYS$OUTPUT _NLA0: +$ CC/OBJECT=TEST.OBJ/INCLUDE=(FREETYPE2) SYS$INPUT +#include <ft2build.h> +#include <freetype/freetype.h> +int main(int argc, char *argv[]) +{ + +#if FREETYPE_MAJOR == 2 && FREETYPE_MINOR <= 1 + printf("This version is too old. Please get newest\n"); + printf("From fafner.dyndns.org/~alexey/libsdl/required.html\n"); + exit(2); +#endif + printf("checking version FreeType : %d.%d.%d\n", + FREETYPE_MAJOR, + FREETYPE_MINOR, + FREETYPE_PATCH); + return(0); +} +$TMP = $STATUS +$DEAS SYS$OUTPUT +$IF (TMP .NE. %X10B90001) +$ THEN +$ HAVE_FREETYPE=0 +$ GOTO NEXT0 +$ENDIF +$DEAS SYS$OUTPUT +$DEFINE SYS$OUTPUT _NLA0: +$LINK/EXE=TEST TEST,FREETYPE2:FREETYPE/OPT +$TMP = $STATUS +$IF (TMP .NE. %X10000001) +$ THEN +$ LINK/EXE=TEST TEST,FREETYPE2:FREETYPE/LIB,ZLIB:LIBZ/LIB +$ TMP = $STATUS +$ IF (TMP .NE. %X10000001) +$ THEN +$ TMP = $STATUS +$ HAVE_FREETYPE=0 +$ GOTO NEXT0 +$ ELSE +$ FREETYPE_STATIC=1 +$ ENDIF +$ENDIF +$! +$RUN TEST +$IF ($STATUS .NE. %X00000001) +$ THEN +$ HAVE_FREETYPE=0 +$ GOTO NEXT0 +$ ELSE +$ HAVE_FREETYPE=1 +$ENDIF +$NEXT0: +$DEAS SYS$OUTPUT +$IF (HAVE_FREETYPE.EQ.1) +$ THEN +$ WRITE SYS$OUTPUT "Checking for correct FreeType ... Yes" +$ RUN TEST +$ ELSE +$ WRITE SYS$OUTPUT "Checking for correct FreeType ... No" +$ WRITE SYS$OUTPUT "This is required library " +$ WRITE SYS$OUTPUT "install it first from fafner.dyndns.org/~alexey/libsdl/required.html" +$ GOTO EXIT +$ENDIF +$! +$! +$HAVE_TIFF=0 +$!"Checking for libPNG " +$ DEFINE SYS$OUTPUT _NLA0: +$ CC/OBJECT=TEST.OBJ/INCLUDE=(PNG,ZLIB) SYS$INPUT + #include <stdlib.h> + #include <png.h> + int main() + { + png_uint_32 n,n1,n2,n3; + n=png_access_version_number(); + n3=n%100; n=n/100; + n2=n%100; n=n/100; + n1=n%100; + if ( (n1<=1)&&(n2<2) ) + { printf("checking version libPNG: %d.%d.%d\n",n1,n2,n3); + printf("This version is too old. Please get newest\n"); + printf("From fafner.dyndns.org/~alexey/libsdl/public.html\n"); + exit(2); + } + printf("checking version libPNG: %d.%d.%d\n",n1,n2,n3); + } +$! +$TMP = $STATUS +$DEAS SYS$OUTPUT +$IF (TMP .NE. %X10B90001) +$ THEN +$ HAVE_LIBPNG=0 +$ GOTO NEXT2 +$ENDIF +$DEFINE SYS$OUTPUT _NLA0: +$LINK/EXE=TEST TEST,PNG:LIBPNG$SHR/OPT,ZLIB:LIBZ/LIB +$TMP = $STATUS +$!WRITE SYS$OUTPUT TMP +$IF (TMP .NE. %X10000001) +$ THEN +$! Trying for static libpng +$ LINK/EXE=TEST TEST,PNG:LIBPNG/LIB,ZLIB:LIBZ/LIB +$ TMP = $STATUS +$ IF (TMP .NE. %X10000001) +$ THEN +$ LIBPNG_STATIC=0 +$ HAVE_LIBPNG=0 +$ GOTO NEXT2 +$ ELSE +$ HAVE_LIBPNG=1 +$ LIBPNG_STATIC=1 +$ ENDIF +$ ELSE +$ HAVE_LIBPNG=1 +$ LIBPNG_STATIC=0 +$ENDIF +$! +$RUN TEST +$IF ($STATUS .NE. %X00000001) +$ THEN +$ HAVE_LIBPNG=0 +$ ELSE +$ HAVE_LIBPNG=1 +$ENDIF +$NEXT2: +$DEAS SYS$OUTPUT +$IF (HAVE_LIBPNG.EQ.1) +$ THEN +$ WRITE SYS$OUTPUT "Checking for correct libPNG ... Yes" +$ RUN TEST +$ ELSE +$ WRITE SYS$OUTPUT "Checking for correct libPNG ... No" +$ WRITE SYS$OUTPUT "This is fatal. Please download and install good library from fafner.dyndns.org/~alexey/libsdl/public.html" +$ GOTO EXIT +$ENDIF +$! +$! +$! +$! Checking for JPEG ... +$ DEFINE SYS$OUTPUT _NLA0: +$ CC/OBJECT=TEST.OBJ/INCLUDE=(JPEG) SYS$INPUT + #include <stdlib.h> + #include <stdio.h> + #include <jpeglib.h> + #include <jversion.h> + int main() + { + printf("checking version jpeg: %s\n",JVERSION); + jpeg_quality_scaling(0); + return 0; + } +$TMP = $STATUS +$DEAS SYS$OUTPUT +$!WRITE SYS$OUTPUT TMP +$IF (TMP .NE. %X10B90001) +$ THEN +$ HAVE_JPEG=0 +$ GOTO NEXT3 +$ENDIF +$DEFINE SYS$OUTPUT _NLA0: +$LINK/EXE=TEST TEST,JPEG:LIBJPEG$SHR/OPT +$TMP = $STATUS +$!WRITE SYS$OUTPUT TMP +$IF (TMP .NE. %X10000001) +$ THEN +$ LINK/EXE=TEST TEST,JPEG:LIBJPEG/OPT +$ TMP = $STATUS +$ IF (TMP .NE. %X10000001) +$ THEN +$ HAVE_JPEG=0 +$ JPEG_STATIC=0 +$ GOTO NEXT3 +$ ELSE +$ HAVE_JPEG=1 +$ JPEG_STATIC=1 +$ ENDIF +$ ELSE +$ HAVE_JPEG=1 +$ JPEG_STATIC=0 +$ENDIF +$! +$NEXT3: +$DEAS SYS$OUTPUT +$IF (HAVE_JPEG.EQ.1) +$ THEN +$ WRITE SYS$OUTPUT "Checking for correct jpeg library ... Yes" +$ ELSE +$ WRITE SYS$OUTPUT "Checking for correct jpeg library ... No" +$ WRITE SYS$OUTPUT "This is fatal. Please download and install good library from fafner.dyndns.org/~alexey/libsdl/public.html" +$ GOTO EXIT +$ENDIF +$RUN TEST +$! +$! +$!Checking for libTIFF +$ DEFINE SYS$OUTPUT _NLA0: +$ DEL TEST.*;* +$ CC/OBJECT=TEST.OBJ/INCLUDE=(TIFF) SYS$INPUT + #include <stdlib.h> + #include <stdio.h> + #include <tiffio.h> + int main() + { + printf("checking libTIFF version:\t%s\n\n", TIFFGetVersion()); + return 0; + } +$! +$TMP = $STATUS +$DEAS SYS$OUTPUT +$IF (TMP .NE. %X10B90001) +$ THEN +$ HAVE_TIFF=0 +$ GOTO NEXT4 +$ENDIF +$DEFINE SYS$OUTPUT _NLA0: +$LINK TEST, TIFF:LIBTIFF/OPT, ZLIB:LIBZ/LIB +$TMP = $STATUS +$!WRITE SYS$OUTPUT TMP +$IF (TMP .NE. %X10000001) +$ THEN +$ HAVE_TIFF=0 +$ ELSE +$ HAVE_TIFF=1 +$ENDIF +$NEXT4: +$DEAS SYS$OUTPUT +$IF (HAVE_TIFF.EQ.1) +$ THEN +$ WRITE SYS$OUTPUT "Checking for TIFF library ... Yes" +$ TIFF_LIBRARY_PATH="TIFF:LIBTIFF/OPT" +$ RUN TEST +$ ELSE +$ WRITE SYS$OUTPUT "Checking for TIFF library ... No" +$ WRITE SYS$OUTPUT "No TIFF library installed. This is fatal. Please download and install good library from fafner.dyndns.org/~alexey/libsdl/public.html" +$ GOTO EXIT +$ENDIF +$! +$! +$!WRITING BUILD FILES +$! +$IF (SHARED.EQ.64) +$ THEN +$ COPY SYS$INPUT [.SRC]LIBGD$DEF.OPT +SYMBOL_VECTOR= (- +gdAlphaBlend=PROCEDURE,- +gdImageCreate=PROCEDURE,- +gdImageCreateTrueColor=PROCEDURE,- +gdImageCreateFromPng=PROCEDURE,- +gdImageCreateFromPngCtx=PROCEDURE,- +gdImageCreateFromPngPtr=PROCEDURE,- +gdImageCreateFromGif=PROCEDURE,- +gdImageCreateFromGifCtx=PROCEDURE,- +gdImageCreateFromGifPtr=PROCEDURE,- +gdImageCreateFromWBMP=PROCEDURE,- +gdImageCreateFromWBMPCtx=PROCEDURE,- +gdImageCreateFromWBMPPtr=PROCEDURE,- +gdImageCreateFromJpeg=PROCEDURE,- +gdImageCreateFromJpegCtx=PROCEDURE,- +gdImageCreateFromJpegPtr=PROCEDURE,- +gdImageCreateFromPngSource=PROCEDURE,- +gdImageCreateFromGd=PROCEDURE,- +gdImageCreateFromGdCtx=PROCEDURE,- +gdImageCreateFromGdPtr=PROCEDURE,- +gdImageCreateFromGd2=PROCEDURE,- +gdImageCreateFromGd2Ctx=PROCEDURE,- +gdImageCreateFromGd2Ptr=PROCEDURE,- +gdImageCreateFromGd2Part=PROCEDURE,- +gdImageCreateFromGd2PartCtx=PROCEDURE,- +gdImageCreateFromGd2PartPtr=PROCEDURE,- +gdImageCreateFromXbm=PROCEDURE,- +gdImageCreateFromXpm=PROCEDURE,- +gdImageStringFTCircle=PROCEDURE,- +gdImageDestroy=PROCEDURE,- +gdImageSetPixel=PROCEDURE,- +gdImageGetPixel=PROCEDURE,- +gdImageGetTrueColorPixel=PROCEDURE,- +gdImageAABlend=PROCEDURE,- +gdImageLine=PROCEDURE,- +gdImageDashedLine=PROCEDURE,- +gdImageRectangle=PROCEDURE,- +gdImageFilledRectangle=PROCEDURE,- +gdImageSetClip=PROCEDURE,- +gdImageGetClip=PROCEDURE,- +gdImageBoundsSafe=PROCEDURE,- +gdImageChar=PROCEDURE,- +gdImageCharUp=PROCEDURE,- +gdImageString=PROCEDURE,- +gdImageStringUp=PROCEDURE,- +gdImageString16=PROCEDURE,- +gdImageStringUp16=PROCEDURE,- +gdFontCacheSetup=PROCEDURE,- +gdFontCacheShutdown=PROCEDURE,- +gdFreeFontCache=PROCEDURE,- +gdImageStringTTF=PROCEDURE,- +gdImageStringFT=PROCEDURE,- +gdFTUseFontConfig=PROCEDURE,- +gdImageStringFTEx=PROCEDURE,- +gdImagePolygon=PROCEDURE,- +gdImageOpenPolygon=PROCEDURE,- +gdImageFilledPolygon=PROCEDURE,- +gdImageColorAllocate=PROCEDURE,- +gdImageColorAllocateAlpha=PROCEDURE,- +gdImageColorClosest=PROCEDURE,- +gdImageColorClosestAlpha=PROCEDURE,- +gdImageColorClosestHWB=PROCEDURE,- +gdImageColorExact=PROCEDURE,- +gdImageColorExactAlpha=PROCEDURE,- +gdImageColorResolve=PROCEDURE,- +gdImageColorResolveAlpha=PROCEDURE,- +gdImageColorDeallocate=PROCEDURE,- +gdImageCreatePaletteFromTrueCol=PROCEDURE,- +gdImageTrueColorToPalette=PROCEDURE,- +gdImageColorTransparent=PROCEDURE,- +gdImagePaletteCopy=PROCEDURE,- +gdImageGif=PROCEDURE,- +gdImagePng=PROCEDURE,- +gdImagePngCtx=PROCEDURE,- +gdImageGifCtx=PROCEDURE,- +gdImagePngEx=PROCEDURE,- +gdImagePngCtxEx=PROCEDURE,- +gdImageWBMP=PROCEDURE,- +gdImageWBMPCtx=PROCEDURE,- +gdFree=PROCEDURE,- +gdImageWBMPPtr=PROCEDURE,- +gdImageJpeg=PROCEDURE,- +gdImageJpegCtx=PROCEDURE,- +gdImageJpegPtr=PROCEDURE,- +gdImageGifAnimBegin=PROCEDURE,- +gdImageGifAnimAdd=PROCEDURE,- +gdImageGifAnimEnd=PROCEDURE,- +gdImageGifAnimBeginCtx=PROCEDURE,- +gdImageGifAnimAddCtx=PROCEDURE,- +gdImageGifAnimEndCtx=PROCEDURE,- +gdImageGifAnimBeginPtr=PROCEDURE,- +gdImageGifAnimAddPtr=PROCEDURE,- +gdImageGifAnimEndPtr=PROCEDURE,- +gdImagePngToSink=PROCEDURE,- +gdImageGd=PROCEDURE,- +gdImageGd2=PROCEDURE,- +gdImageGifPtr=PROCEDURE,- +gdImagePngPtr=PROCEDURE,- +gdImagePngPtrEx=PROCEDURE,- +gdImageGdPtr=PROCEDURE,- +gdImageGd2Ptr=PROCEDURE,- +gdImageFilledArc=PROCEDURE,- +gdImageArc=PROCEDURE,- +gdImageFilledEllipse=PROCEDURE,- +gdImageFillToBorder=PROCEDURE,- +gdImageFill=PROCEDURE,- +gdImageCopy=PROCEDURE,- +gdImageCopyMerge=PROCEDURE,- +gdImageCopyMergeGray=PROCEDURE,- +gdImageCopyResized=PROCEDURE,- +gdImageCopyResampled=PROCEDURE,- +gdImageCopyRotated=PROCEDURE,- +gdImageSetBrush=PROCEDURE,- +gdImageSetTile=PROCEDURE,- +gdImageSetAntiAliased=PROCEDURE,- +gdImageSetAntiAliasedDontBlend=PROCEDURE,- +gdImageSetStyle=PROCEDURE,- +gdImageSetThickness=PROCEDURE,- +gdImageInterlace=PROCEDURE,- +gdImageAlphaBlending=PROCEDURE,- +gdImageSaveAlpha=PROCEDURE,- +gdNewFileCtx=PROCEDURE,- +gdNewDynamicCtx=PROCEDURE,- +gdNewDynamicCtxEx=PROCEDURE,- +gdNewSSCtx=PROCEDURE,- +gdDPExtractData=PROCEDURE,- +gdFontGetGiant=PROCEDURE,- +gdFontGetLarge=PROCEDURE,- +gdFontGetMediumBold=PROCEDURE,- +gdFontGetSmall=PROCEDURE,- +gdFontGetTiny=PROCEDURE,- +gdImageCompare=PROCEDURE,- +gdImageCreateFromTiff=PROCEDURE,- +gdImageCreateFromTiffCtx=PROCEDURE,- +gdImageCreateFromTiffPtr=PROCEDURE,- +gdImageCreateFromTga=PROCEDURE,- +gdImageCreateFromTgaCtx=PROCEDURE,- +gdImageCreateFromTgaPtr=PROCEDURE,- +gdImageTiff=PROCEDURE,- +gdImageTiffPtr=PROCEDURE,- +gdImageTiffCtx=PROCEDURE,- +gdImageCrop=PROCEDURE,- +gdImageAutoCrop=PROCEDURE,- +gdImageThresholdCrop=PROCEDURE,- +gdFontGiant=DATA,- +GDFONTLARGE=DATA,- +GDFONTMEDIUMBOLD=DATA,- +GDFONTSMALL=DATA,- +GDFONTTINY=DATA- +) +$ENDIF +$! +$IF (SHARED.EQ.32) +$ THEN +$ COPY SYS$INPUT [.SRC]LIBGD$DEF.OPT +UNIVERSAL=gdAlphaBlend +UNIVERSAL=gdImageCreate +UNIVERSAL=gdImageCreateTrueColor +UNIVERSAL=gdImageCreateFromPng +UNIVERSAL=gdImageCreateFromPngCtx +UNIVERSAL=gdImageCreateFromPngPtr +UNIVERSAL=gdImageCreateFromGif +UNIVERSAL=gdImageCreateFromGifCtx +UNIVERSAL=gdImageCreateFromGifPtr +UNIVERSAL=gdImageCreateFromWBMP +UNIVERSAL=gdImageCreateFromWBMPCtx +UNIVERSAL=gdImageCreateFromWBMPPtr +UNIVERSAL=gdImageCreateFromJpeg +UNIVERSAL=gdImageStringFTCircle +UNIVERSAL=gdImageCreateFromJpegCtx +UNIVERSAL=gdImageCreateFromJpegPtr +UNIVERSAL=gdImageCreateFromPngSource +UNIVERSAL=gdImageCreateFromGd +UNIVERSAL=gdImageCreateFromGdCtx +UNIVERSAL=gdImageCreateFromGdPtr +UNIVERSAL=gdImageCreateFromGd2 +UNIVERSAL=gdImageCreateFromGd2Ctx +UNIVERSAL=gdImageCreateFromGd2Ptr +UNIVERSAL=gdImageCreateFromGd2Part +UNIVERSAL=gdImageCreateFromGd2PartCtx +UNIVERSAL=gdImageCreateFromGd2PartPtr +UNIVERSAL=gdImageCreateFromXbm +UNIVERSAL=gdImageCreateFromXpm +UNIVERSAL=gdImageDestroy +UNIVERSAL=gdImageSetPixel +UNIVERSAL=gdImageGetPixel +UNIVERSAL=gdImageGetTrueColorPixel +UNIVERSAL=gdImageAABlend +UNIVERSAL=gdImageLine +UNIVERSAL=gdImageDashedLine +UNIVERSAL=gdImageRectangle +UNIVERSAL=gdImageFilledRectangle +UNIVERSAL=gdImageSetClip +UNIVERSAL=gdImageGetClip +UNIVERSAL=gdImageBoundsSafe +UNIVERSAL=gdImageChar +UNIVERSAL=gdImageCharUp +UNIVERSAL=gdImageString +UNIVERSAL=gdImageStringUp +UNIVERSAL=gdImageString16 +UNIVERSAL=gdImageStringUp16 +UNIVERSAL=gdFontCacheSetup +UNIVERSAL=gdFontCacheShutdown +UNIVERSAL=gdFreeFontCache +UNIVERSAL=gdImageStringTTF +UNIVERSAL=gdImageStringFT +UNIVERSAL=gdFTUseFontConfig +UNIVERSAL=gdImageStringFTEx +UNIVERSAL=gdImagePolygon +UNIVERSAL=gdImageOpenPolygon +UNIVERSAL=gdImageFilledPolygon +UNIVERSAL=gdImageColorAllocate +UNIVERSAL=gdImageColorAllocateAlpha +UNIVERSAL=gdImageColorClosest +UNIVERSAL=gdImageColorClosestAlpha +UNIVERSAL=gdImageColorClosestHWB +UNIVERSAL=gdImageColorExact +UNIVERSAL=gdImageColorExactAlpha +UNIVERSAL=gdImageColorResolve +UNIVERSAL=gdImageColorResolveAlpha +UNIVERSAL=gdImageColorDeallocate +UNIVERSAL=gdImageCreatePaletteFromTrueCol +UNIVERSAL=gdImageTrueColorToPalette +UNIVERSAL=gdImageColorTransparent +UNIVERSAL=gdImagePaletteCopy +UNIVERSAL=gdImageGif +UNIVERSAL=gdImagePng +UNIVERSAL=gdImagePngCtx +UNIVERSAL=gdImageGifCtx +UNIVERSAL=gdImagePngEx +UNIVERSAL=gdImagePngCtxEx +UNIVERSAL=gdImageWBMP +UNIVERSAL=gdImageWBMPCtx +UNIVERSAL=gdFree +UNIVERSAL=gdImageWBMPPtr +UNIVERSAL=gdImageJpeg +UNIVERSAL=gdImageJpegCtx +UNIVERSAL=gdImageJpegPtr +UNIVERSAL=gdImageGifAnimBegin +UNIVERSAL=gdImageGifAnimAdd +UNIVERSAL=gdImageGifAnimEnd +UNIVERSAL=gdImageGifAnimBeginCtx +UNIVERSAL=gdImageGifAnimAddCtx +UNIVERSAL=gdImageGifAnimEndCtx +UNIVERSAL=gdImageGifAnimBeginPtr +UNIVERSAL=gdImageGifAnimAddPtr +UNIVERSAL=gdImageGifAnimEndPtr +UNIVERSAL=gdImagePngToSink +UNIVERSAL=gdImageGd +UNIVERSAL=gdImageGd2 +UNIVERSAL=gdImageGifPtr +UNIVERSAL=gdImagePngPtr +UNIVERSAL=gdImagePngPtrEx +UNIVERSAL=gdImageGdPtr +UNIVERSAL=gdImageGd2Ptr +UNIVERSAL=gdImageFilledArc +UNIVERSAL=gdImageArc +UNIVERSAL=gdImageFilledEllipse +UNIVERSAL=gdImageFillToBorder +UNIVERSAL=gdImageFill +UNIVERSAL=gdImageCopy +UNIVERSAL=gdImageCopyMerge +UNIVERSAL=gdImageCopyMergeGray +UNIVERSAL=gdImageCopyResized +UNIVERSAL=gdImageCopyResampled +UNIVERSAL=gdImageCopyRotated +UNIVERSAL=gdImageSetBrush +UNIVERSAL=gdImageSetTile +UNIVERSAL=gdImageSetAntiAliased +UNIVERSAL=gdImageSetAntiAliasedDontBlend +UNIVERSAL=gdImageSetStyle +UNIVERSAL=gdImageSetThickness +UNIVERSAL=gdImageInterlace +UNIVERSAL=gdImageAlphaBlending +UNIVERSAL=gdImageSaveAlpha +UNIVERSAL=gdNewFileCtx +UNIVERSAL=gdNewDynamicCtx +UNIVERSAL=gdNewDynamicCtxEx +UNIVERSAL=gdNewSSCtx +UNIVERSAL=gdDPExtractData +UNIVERSAL=gdFontGetGiant +UNIVERSAL=gdFontGetLarge +UNIVERSAL=gdFontGetMediumBold +UNIVERSAL=gdFontGetSmall +UNIVERSAL=gdFontGetTiny +UNIVERSAL=gdImageCompare +UNIVERSAL=gdFontGiant +UNIVERSAL=gdImageCreateFromTiff +UNIVERSAL=gdImageCreateFromTiffCtx +UNIVERSAL=gdImageCreateFromTiffPtr +UNIVERSAL=gdImageCreateFromTga +UNIVERSAL=gdImageCreateFromTgaCtx +UNIVERSAL=gdImageCreateFromTgaPtr +UNIVERSAL=gdImageTiff +UNIVERSAL=gdImageTiffPtr +UNIVERSAL=gdImageTiffCtx +UNIVERSAL=gdImageCrop +UNIVERSAL=gdImageAutoCrop +UNIVERSAL=gdImageThresholdCrop +UNIVERSAL=GDFONTLARGE +UNIVERSAL=GDFONTMEDIUMBOLD +UNIVERSAL=GDFONTSMALL +UNIVERSAL=GDFONTTINY + +$ENDIF +$! +$! +$DEF SYS$OUTPUT _NL0: +$! +$!Making OPT file for GD$SHR.EXE, i.e without reference to himself +$COPY SYS$INPUT [.SRC]OPT.OPT +[]GD/LIB +$IF ((HAVE_LIBPNG.EQ.1) .AND. (LIBPNG_STATIC.EQ.1)) +$ THEN +$ APP SYS$INPUT [.SRC]OPT.OPT +PNG:LIBPNG/LIB +$ENDIF +$IF ((HAVE_LIBPNG.EQ.1) .AND. (LIBPNG_STATIC.EQ.0)) +$ THEN +$ APP PNG:LIBPNG$SHR.OPT [.SRC]OPT.OPT +$ENDIF +$! +$IF ((HAVE_JPEG.EQ.1) .AND. (JPEG_STATIC.EQ.1) .AND. (HAVE_TIFF.NE.1)) +$ THEN +$ APP SYS$INPUT [.SRC]OPT.OPT +JPEG:LIBJPEG/LIB +$ENDIF +$IF ((HAVE_JPEG.EQ.1) .AND. (JPEG_STATIC.EQ.0) .AND. (HAVE_TIFF.NE.1)) +$ THEN +$ APP JPEG:LIBJPEG$SHR.OPT [.SRC]OPT.OPT +$ENDIF +$! +$IF (HAVE_TIFF.EQ.1) +$ THEN +$ APP TIFF:LIBTIFF.OPT [.SRC]OPT.OPT +$ENDIF +$! +$IF (HAVE_FREETYPE.EQ.1) .AND. (FREETYPE_STATIC.EQ.1) +$ THEN +$ APP SYS$INPUT [.SRC]OPT.OPT + FREETYPE2:FREETYPE/LIB + ZLIB:LIBZ/LIB +$ENDIF +$IF (HAVE_FREETYPE.EQ.1) .AND. (FREETYPE_STATIC.EQ.0) +$ THEN +$ APP FREETYPE2:FREETYPE.OPT [.SRC]OPT.OPT +$ENDIF +$! +$IF (HAVE_ZLIB.EQ.1) .AND. ((FREETYPE_STATIC.NE.1).AND.(JPEG_STATIC.NE.1)) +$ THEN +$ IF (ZLIB_STATIC.EQ.0) +$ THEN +$ APP SYS$INPUT [.SRC]OPT.OPT + SYS$SHARE:LIBZSHR/SHARE +$ ELSE +$ APP SYS$INPUT [.SRC]OPT.OPT + ZLIB:LIBZ/LIB +$ ENDIF +$ ELSE +$ APP SYS$INPUT [.SRC]OPT.OPT + ZLIB:LIBZ/LIB +$ENDIF +$! +$! +$PURGE [.SRC]OPT.OPT +$! +$! +$!Making working LIBGD.OPT file +$! +$IF (SHARED.GT.0) +$ THEN + $COPY SYS$INPUT [.SRC]LIBGD.OPT + SYS$SHARE:GD$SHR/SHARE +$ ELSE + $COPY SYS$INPUT [.SRC]LIBGD.OPT + LIBGD:GD/LIB +$ENDIF +$! +$!Append OPT files to LIBGD.OPT +$IF ((HAVE_LIBPNG.EQ.1) .AND. (LIBPNG_STATIC.EQ.1)) +$ THEN +$ APP SYS$INPUT [.SRC]LIBGD.OPT +PNG:LIBPNG/LIB +$ENDIF +$IF ((HAVE_LIBPNG.EQ.1) .AND. (LIBPNG_STATIC.EQ.0)) +$ THEN +$ APP PNG:LIBPNG$SHR.OPT [.SRC]LIBGD.OPT +$ENDIF +$! +$IF ((HAVE_JPEG.EQ.1) .AND. (HAVE_TIFF.NE.1) .AND. (JPEG_STATIC.EQ.1)) +$ THEN +$ APP JPEG:LIBJPEG.OPT [.SRC]LIBGD.OPT +$ENDIF +$IF ((HAVE_JPEG.EQ.1) .AND. (JPEG_STATIC.EQ.0) .AND. (HAVE_TIFF.NE.1)) +$ THEN +$ APP JPEG:LIBJPEG$SHR.OPT [.SRC]LIBGD.OPT +$ENDIF +$! +$IF (HAVE_TIFF.EQ.1) +$ THEN +$ APP TIFF:LIBTIFF.OPT [.SRC]LIBGD.OPT +$ENDIF +$! +$IF (HAVE_FREETYPE.EQ.1) .AND. (FREETYPE_STATIC.EQ.1) +$ THEN +$ APP SYS$INPUT [.SRC]LIBGD.OPT + FREETYPE2:FREETYPE/LIB + ZLIB:LIBZ/LIB +$ENDIF +$IF (HAVE_FREETYPE.EQ.1) .AND. (FREETYPE_STATIC.EQ.0) +$ THEN +$ APP FREETYPE2:FREETYPE.OPT [.SRC]LIBGD.OPT +$ENDIF +$! +$IF (HAVE_ZLIB.EQ.1) .AND. ((FREETYPE_STATIC.NE.1).AND.(JPEG_STATIC.NE.1)) +$ THEN +$ IF (ZLIB_STATIC.EQ.0) +$ THEN +$ APP SYS$INPUT [.SRC]LIBGD.OPT + SYS$SHARE:LIBZSHR/SHARE +$ ELSE +$ APP SYS$INPUT [.SRC]LIBGD.OPT + ZLIB:LIBZ/LIB +$ ENDIF +$ENDIF +$! +$PURGE LIBGD.OPT +$! +$DEAS SYS$OUTPUT +$! +$OPEN/WRITE OUT BUILD.COM +$ WRITE OUT "$SET DEF [.SRC]" +$ WRITE OUT "$",MAKE +$ WRITE OUT "$ CURRENT = F$ENVIRONMENT (""DEFAULT"") " +$ WRITE OUT "$TMP=CURRENT" +$ WRITE OUT "$OPEN/WRITE OUTT [-]LIBGD$STARTUP.COM" +$ WRITE OUT "$WRITE OUTT ""DEFINE LIBGD """"", "'","'","TMP'""""""" +$ WRITE OUT "$WRITE OUTT ""GD2COPYPAL==""""$","'","'","TMP'"",""GD2COPYPAL"""" " +$ WRITE OUT "$WRITE OUTT ""GD2TIME==""""$","'","'","TMP'"",""GD2TIME"""" " +$ WRITE OUT "$WRITE OUTT ""GD2TOGIF==""""$","'","'","TMP'"",""GD2TOGIF"""" " +$ WRITE OUT "$WRITE OUTT ""GD2TOPNG==""""$","'","'","TMP'"",""GD2TOPNG"""" " +$ WRITE OUT "$WRITE OUTT ""GDCMPGIF==""""$","'","'","TMP'"",""GDCMPGIF"""" " +$ WRITE OUT "$WRITE OUTT ""GDTOPNG==""""$","'","'","TMP'"",""GDTOPNG"""" " +$ WRITE OUT "$WRITE OUTT ""GIFTOGD2==""""$","'","'","TMP'"",""GIFTOGD2"""" " +$ WRITE OUT "$WRITE OUTT ""PNGTOGD==""""$","'","'","TMP'"",""PNGTOGD"""" " +$ WRITE OUT "$WRITE OUTT ""PNGTOGD2==""""$","'","'","TMP'"",""PNGTOGD2"""" " +$ WRITE OUT "$WRITE OUTT ""WEBPNG==""""$","'","'","TMP'"",""WEBPNG"""" " +$ WRITE OUT "$CLOSE OUTT" +$! +$ WRITE OUT "$WRITE SYS$OUTPUT "" "" " +$ WRITE OUT "$WRITE SYS$OUTPUT ""***************************************************************************** "" " +$ WRITE OUT "$WRITE SYS$OUTPUT ""LIBGD$STARTUP.COM has been created. "" " +$ WRITE OUT "$WRITE SYS$OUTPUT ""This file setups all logicals needed. It should be execute before using "" " +$ WRITE OUT "$WRITE SYS$OUTPUT ""Nice place to call it - LOGIN.COM "" " +$ WRITE OUT "$WRITE SYS$OUTPUT """" " +$ WRITE OUT "$WRITE SYS$OUTPUT ""Using:"" " +$ WRITE OUT "$WRITE SYS$OUTPUT ""CC/INCL=LIBGD PROG"" " +$ WRITE OUT "$WRITE SYS$OUTPUT ""LINK PROG, LIBGD:LIBGD/OPT"" " +$ WRITE OUT "$WRITE SYS$OUTPUT ""***************************************************************************** "" " +$ WRITE OUT "$WRITE SYS$OUTPUT ""***************************************************************************** "" " +$ WRITE OUT "$SET DEF [-]" +$CLOSE OUT +$! +$! +$!Writing config.h +$COPY SYS$INPUT [.SRC]CONFIG.H +/* Generated by configure.com for OpenVMS */ + +/* Define to 1 if you have the <dlfcn.h> header file. */ +#define HAVE_DLFCN_H 1 + +/* Define to 1 if you have the <errno.h> header file. */ +#define HAVE_ERRNO_H 1 + + + +/* Define to 1 if you have the <inttypes.h> header file. */ +#define HAVE_INTTYPES_H 1 + + +#define PACKAGE_NAME "GD" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "GD 2.1.0" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "GD" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "2.1.0" + +/* Define to necessary symbol if this constant uses a non-standard name on + * your system. */ +/* #undef PTHREAD_CREATE_JOINABLE */ + +/* Define to 1 if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Version number of package */ +#define VERSION "2.1.0" + +/* Define to 1 if you have the `m' library (-lm). */ +#define HAVE_LIBM 1 + + +/* Define to 1 if you have the <libpng/png.h> header file. */ +/* #undef HAVE_LIBPNG_PNG_H */ + + + +/* Define to 1 if you have the <limits.h> header file. */ +//#define HAVE_LIMITS_H 1 + + +/* Define to 1 if you have the <memory.h> header file. */ +#define HAVE_MEMORY_H 1 + + +/* Define if you have POSIX threads libraries and header files. */ +#define HAVE_PTHREAD 1 + +/* Define to 1 if you have the <stddef.h> header file. */ +#define HAVE_STDDEF_H 1 + +/* Define to 1 if you have the <stdint.h> header file. */ +//#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the <stdlib.h> header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if you have the <strings.h> header file. */ +#define HAVE_STRINGS_H 1 + +/* Define to 1 if you have the <string.h> header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if you have the <sys/stat.h> header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the <sys/types.h> header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the <unistd.h> header file. */ +#define HAVE_UNISTD_H 1 + +/* Define as const if the declaration of iconv() needs const. */ +//#define ICONV_CONST + +/* Name of package */ +#define PACKAGE "gd" + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "http://bugs.libgd.org" + +/* Define to the full name of this package. */ + + + +$IF HAVE_ICONV.EQ.1 +$ THEN +$ APP SYS$INPUT [.SRC]CONFIG.H + /* Define if you have the iconv() function. */ + #define HAVE_ICONV 1 + /* Define to 1 if you have the <iconv.h> header file. */ + #define HAVE_ICONV_H 1 + /* Define if <iconv.h> defines iconv_t. */ + #define HAVE_ICONV_T_DEF 1 +$ENDIF +$IF HAVE_TIFF.EQ.1 +$ THEN +$ APP SYS$INPUT [.SRC]CONFIG.H + #define HAVE_LIBTIFF 1 +$ENDIF +$IF HAVE_LIBPNG.EQ.1 +$ THEN +$ APP SYS$INPUT [.SRC]CONFIG.H + #define HAVE_LIBPNG 1 + #define HAVE_PNG_H 1 +$ENDIF +$IF HAVE_FREETYPE.EQ.1 +$ THEN +$ APP SYS$INPUT [.SRC]CONFIG.H + #define HAVE_LIBFREETYPE 1 + #define HAVE_FT2BUILD_H 1 +$ENDIF +$IF HAVE_JPEG.EQ.1 +$ THEN +$ APP SYS$INPUT [.SRC]CONFIG.H + #define HAVE_LIBJPEG 1 +$ENDIF +$IF HAVE_ZLIB.EQ.1 +$ THEN +$ APP SYS$INPUT [.SRC]CONFIG.H + #define HAVE_LIBZ 1 +$ENDIF +$IF HAVE_TIFF.EQ.1 +$ THEN +$ APP SYS$INPUT [.SRC]CONFIG.H + #define HAVE_LIBTIFF 1 +$ENDIF +$! +$! +$! +$! +$COP SYS$INPUT [.SRC]DESCRIP.MMS +# Generated by CONFIGURE.COM +# Alexey Chupahin elvis_75@mail.ru +# OpenVMS 7.3-1,8.2 DEC 2000 mod.300 +# OpenVMS 8.3 HP rx1620 + + +.FIRST + DEF LIBGD [] + +CC=cc +CFLAGS=/OPT=(INLINE=SPEED) /INCL=([],JPEG,PNG,FREETYPE2,ZLIB,TIFF) /DEF=(HAVE_CONFIG_H)/WARN=(DIS=MACROREDEF) +LIBS=[]LIBGD/OPT + + +ALL : \ +gd.olb,\ +$IF (SHARED.GT.0) +$ THEN +$ APP SYS$INPUT [.SRC]DESCRIP.MMS +gd$shr.exe,\ +$ENDIF +$! +$APP SYS$INPUT [.SRC]DESCRIP.MMS +annotate.exe,\ +circletexttest.exe,\ +fontconfigtest.exe,\ +circletexttest.exe,\ +fontconfigtest.exe,\ +fontsizetest.exe,\ +fontwheeltest.exe,\ +gd2copypal.exe,\ +gd2time.exe,\ +gd2togif.exe,\ +gd2topng.exe,\ +gdcmpgif.exe,\ +gddemo.exe,\ +gdtest.exe,\ +gdtestft.exe,\ +gdtopng.exe,\ +gifanimtest.exe,\ +giftogd2.exe,\ +pngtogd.exe,\ +pngtogd2.exe,\ +testac.exe,\ +testtr.exe,\ +webpng.exe,\ +gdparttopng.exe + $! + +annotate.exe : annotate.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + +circletexttest.exe : circletexttest.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + +fontconfigtest.exe : fontconfigtest.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + +fontsizetest.exe : fontsizetest.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + +fontwheeltest.exe : fontwheeltest.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + +gd2copypal.exe : gd2copypal.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + +gd2time.exe : gd2time.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + +gd2togif.exe : gd2togif.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + +gd2topng.exe : gd2topng.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + + +gdcmpgif.exe : gdcmpgif.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + + +gddemo.exe : gddemo.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + + +gdtest.exe : gdtest.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + + +gdtestft.exe : gdtestft.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + + +gdtopng.exe : gdtopng.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + + +gifanimtest.exe : gifanimtest.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + +giftogd2.exe : giftogd2.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + +giftogd2.obj : giftogd2.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + + +pngtogd.exe : pngtogd.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + + +pngtogd2.exe : pngtogd2.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + + +testac.exe : testac.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + + +testtr.exe : testtr.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + + +webpng.exe : webpng.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + + +gdparttopng.exe : gdparttopng.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=TMP.OBJ + LINK/EXE=$(MMS$TARGET) TMP.OBJ, $(LIBS) + DEL TMP.OBJ;* + + +OBJ=\ +gd.obj,\ +gdcache.obj,\ +gdfontg.obj,\ +gdfontl.obj,\ +gdfontmb.obj,\ +gdfonts.obj,\ +gdfontt.obj,\ +gdft.obj,\ +gdfx.obj,\ +gdhelpers.obj,\ +gdkanji.obj,\ +gdtables.obj,\ +gdxpm.obj,\ +gd_bmp.obj,\ +gd_gd.obj,\ +gd_gd2.obj,\ +gd_gif_in.obj,\ +gd_gif_out.obj,\ +gd_io.obj,\ +gd_io_dp.obj,\ +gd_io_file.obj,\ +gd_io_ss.obj,\ +gd_jpeg.obj,\ +gd_png.obj,\ +gd_security.obj,\ +gd_ss.obj,\ +gd_crop.obj,\ +gd_tga.obj,\ +gd_tiff.obj,\ +gd_transform.obj,\ +gd_topal.obj,\ +gd_wbmp.obj,\ +wbmp.obj + + +gd_transform.obj : gd_transform.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_tiff.obj : gd_tiff.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_tga.obj : gd_tga.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_bmp.obj : gd_bmp.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_crop.obj : gd_crop.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd.obj : gd.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gdcache.obj : gdcache.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gdfontg.obj : gdfontg.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gdfontl.obj : gdfontl.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gdfontmb.obj : gdfontmb.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gdfonts.obj : gdfonts.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gdfontt.obj : gdfontt.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gdft.obj : gdft.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gdfx.obj : gdfx.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gdhelpers.obj : gdhelpers.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gdkanji.obj : gdkanji.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gdtables.obj : gdtables.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gdxpm.obj : gdxpm.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_gd.obj : gd_gd.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_gd2.obj : gd_gd2.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_gif_in.obj : gd_gif_in.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_gif_out.obj : gd_gif_out.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_io.obj : gd_io.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_io_dp.obj : gd_io_dp.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_io_file.obj : gd_io_file.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_io_ss.obj : gd_io_ss.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_jpeg.obj : gd_jpeg.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_png.obj : gd_png.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_security.obj : gd_security.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_ss.obj : gd_ss.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_topal.obj : gd_topal.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +gd_wbmp.obj : gd_wbmp.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + +wbmp.obj : wbmp.c + $(CC) $(CFLAGS) $(MMS$SOURCE) /OBJ=$(MMS$TARGET) + + +GD.OLB : $(OBJ) + LIB/CREA GD.OLB $(OBJ) + +GD$SHR.EXE : $(OBJ) + LINK/SHARE=GD$SHR GD.OBJ,LIBGD$DEF/OPT,OPT/OPT + COPY GD$SHR.EXE SYS$SHARE + +CLEAN : + DEL [...]*.OBJ;* + DEL [...]*.OLB;* + DEL [...]*.EXE;* +$!DEL TMP.MMS;* +$! +$IF (F$SEARCH("[.SRC]GD.H;2").EQS."") +$ THEN +$ WRITE SYS$OUTPUT "Patching GD.H" +$ DEF SYS$OUTPUT "_NLA0:" +$ COPY SYS$INPUT [.SRC]GD.H;2 +#define gdImageCreatePaletteFromTrueColor gdImageCreatePaletteFromTrueCol + +$ APP [.SRC]GD.H;1 [.SRC]GD.H;2 +$ DEAS SYS$INPUT +$ENDIF +$! +$! +$! +$! +$WRITE SYS$OUTPUT " " +$WRITE SYS$OUTPUT " " +$WRITE SYS$OUTPUT "Now you can type @BUILD " +$! +$EXIT: +$DEFINE SYS$OUTPUT _NLA0: +$DEL TEST.OBJ;* +$DEL TEST.C;* +$DEL TEST.EXE;* +$DEAS SYS$OUTPUT diff --git a/Build/source/libs/gd/libgd-2.1.1/VMS/README.VMS b/Build/source/libs/gd/libgd-2.1.1/VMS/README.VMS new file mode 100644 index 00000000000..cdeee561654 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/VMS/README.VMS @@ -0,0 +1,71 @@ +Dear OpenVMS user, + +Installation process is identical to one in *nix* world and consist to +four simple steps: +1. Installing required libraries +2. Configuration +3. Compiling +4. Installation. + + +1. Please install required libraries first: + +1. ZLIB 1.2 or newer +2. PNG 1.2.12 or newer +3. FreeType 2 +4. JPEG 6B + +All may be found at OpenVMS libSDL porting project site +http://fafner.dyndns.org/~alexey/libsdl/required.html + +Also, system should have MMS make utility from DEC or +free analogue MMK. And C compiler with runtime, of course. ;) + + +2. Configuration is doing automatically by a configuration script: + +$@[.VMS]CONFIGURE + +The script detects hardware,system and required libraries have been installed. +Compilation stage will be prepeared to create shared and static libraries. +Alpha,IA64 or VAX platform are supported. Optional argument "static" +tells to configurator to make static libraries only: + +$@[.VMS]CONFIGURE STATIC + +CONFIGURE script checks your ZLIB, FREETYPE, JPEG, PNG libraries. +If it detects any troubles, you may get and install good and tested ones +from OpenVMS libSDL porting project site: +http://fafner.dyndns.org/~alexey/libsdl/required.html + +When success, it creates a building script named BUILD.COM + +3. Compilation: + +$@BUILD + +It should be error-free. + +When success, it creates a setup script named LIBGD$STARTUP.COM + +4. Setup OpenVMS environment before using libGD: + +$@LIBGD$STARTUP + +LIBGD and its utilites are ready to using. + +Optionally you may insert this startup file into your LOGIN.COM +to set libGD environment every time you login automatically. + +To learn libGD please refer libGD official documentation. +Compiling with library should be: + +$CC/INCL=LIBGD PROG +$LINK PROG, LIBGD:LIBGD/OPT + + + +yours, +Alexey Chupahin +Rostov-on-Don, Russia +elvis_75@mail.ru alex@rostov.rs-ultra.ru diff --git a/Build/source/libs/gd/libgd-2.1.1/bootstrap.sh b/Build/source/libs/gd/libgd-2.1.1/bootstrap.sh new file mode 100755 index 00000000000..dac639eeaa4 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/bootstrap.sh @@ -0,0 +1,53 @@ +#!/bin/sh -- +# $Id$ +# Small shell script to build gd from source + +# Generate the manual (unless naturaldocs isn't installed). Source +# dists should include the docs so that end users don't need to +# install naturaldocs. At the same time, we tolerate it being missing +# so that random hackers don't need it just to build the code. +if which naturaldocs > /dev/null; then + echo "Generation user docs:" + (cd docs/naturaldocs; bash run_docs.sh) +else + echo "Can't find naturaldocs; not generating user manual." +fi + + +# allow importing from the environment, e.g. +# "AUTOCONF=autoconf259 ... ./bootstrap.sh" +if echo $OSTYPE | grep -q '^darwin' ; then + echo Having trouble on OS X? Try brew install autoconf libtool automake gettext apple-gcc42 pkg-config cmake + LIBTOOLIZE=${LIBTOOLIZE:-glibtoolize} +fi +ACLOCAL=${ACLOCAL:-aclocal} +AUTOCONF=${AUTOCONF:-autoconf} +AUTOHEADER=${AUTOHEADER:-autoheader} +AUTOMAKE=${AUTOMAKE:-automake} +LIBTOOLIZE=${LIBTOOLIZE:-libtoolize} + +# might handle this differently +AUTOMAKE_FLAGS="--add-missing --copy" + +# +CLEANFILES="Makefile.in aclocal.m4 autom4te.cache configure libtool config/Makefile.in \ +tests/Makefile.in src/Makefile.in" + +# +rm -rf ${CLEANFILES} + +# +if ${ACLOCAL} -I m4 \ + && ${LIBTOOLIZE} --automake --copy --force \ + && ${ACLOCAL} -I m4 \ + && ${AUTOHEADER} \ + && ${AUTOMAKE} ${AUTOMAKE_FLAGS} \ + && ${AUTOCONF} --force && [ -f configure ] +then + echo Now run configure and make +else + echo Failed + exit 1 +fi + +exit 0 diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/AC_HEADER_STDC.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/AC_HEADER_STDC.cmake new file mode 100644 index 00000000000..cf4fff83ba5 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/AC_HEADER_STDC.cmake @@ -0,0 +1,42 @@ +message(STATUS "Checking whether system has ANSI C header files") +include(CheckPrototypeExists) + +include(CheckPrototypeExists) +check_include_files("dlfcn.h;stdint.h;stddef.h;inttypes.h;stdlib.h;strings.h;string.h;float.h" StandardHeadersExist) +if(StandardHeadersExist) + check_prototype_exists(memchr string.h memchrExists) + if(memchrExists) + + check_prototype_exists(free stdlib.h freeExists) + if(freeExists) + message(STATUS "ANSI C header files - found") + set(STDC_HEADERS 1 CACHE INTERNAL "System has ANSI C header files") + set(HAVE_STRINGS_H 1) + set(HAVE_STRING_H 1) + set(HAVE_FLOAT_H 1) + set(HAVE_STDLIB_H 1) + set(HAVE_STDDEF_H 1) + set(HAVE_STDINT_H 1) + set(HAVE_INTTYPES_H 1) + set(HAVE_DLFCN_H 1) + endif(freeExists) + endif(memchrExists) +endif(StandardHeadersExist) + +if(NOT STDC_HEADERS) + message(STATUS "ANSI C header files - not found") + set(STDC_HEADERS 0 CACHE INTERNAL "System has ANSI C header files") +endif(NOT STDC_HEADERS) + + +check_include_files(unistd.h HAVE_UNISTD_H) + +include(CheckDIRSymbolExists) +check_dirsymbol_exists("sys/stat.h;sys/types.h;dirent.h" HAVE_DIRENT_H) +if (HAVE_DIRENT_H) + set(HAVE_SYS_STAT_H 1) + set(HAVE_SYS_TYPES_H 1) +endif (HAVE_DIRENT_H) + +check_include_files("dlfcn.h;stdint.h;stddef.h;inttypes.h;stdlib.h;strings.h;string.h;float.h" StandardHeadersExist) +set(HAVE_LIBM 1) diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/CMakeParseArguments.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/CMakeParseArguments.cmake new file mode 100644 index 00000000000..b57b0296d3f --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/CMakeParseArguments.cmake @@ -0,0 +1,156 @@ +# CMAKE_PARSE_ARGUMENTS(<prefix> <options> <one_value_keywords> <multi_value_keywords> args...) +# +# CMAKE_PARSE_ARGUMENTS() is intended to be used in macros or functions for +# parsing the arguments given to that macro or function. +# It processes the arguments and defines a set of variables which hold the +# values of the respective options. +# +# The <options> argument contains all options for the respective macro, +# i.e. keywords which can be used when calling the macro without any value +# following, like e.g. the OPTIONAL keyword of the install() command. +# +# The <one_value_keywords> argument contains all keywords for this macro +# which are followed by one value, like e.g. DESTINATION keyword of the +# install() command. +# +# The <multi_value_keywords> argument contains all keywords for this macro +# which can be followed by more than one value, like e.g. the TARGETS or +# FILES keywords of the install() command. +# +# When done, CMAKE_PARSE_ARGUMENTS() will have defined for each of the +# keywords listed in <options>, <one_value_keywords> and +# <multi_value_keywords> a variable composed of the given <prefix> +# followed by "_" and the name of the respective keyword. +# These variables will then hold the respective value from the argument list. +# For the <options> keywords this will be TRUE or FALSE. +# +# All remaining arguments are collected in a variable +# <prefix>_UNPARSED_ARGUMENTS, this can be checked afterwards to see whether +# your macro was called with unrecognized parameters. +# +# As an example here a my_install() macro, which takes similar arguments as the +# real install() command: +# +# function(MY_INSTALL) +# set(options OPTIONAL FAST) +# set(oneValueArgs DESTINATION RENAME) +# set(multiValueArgs TARGETS CONFIGURATIONS) +# cmake_parse_arguments(MY_INSTALL "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} ) +# ... +# +# Assume my_install() has been called like this: +# my_install(TARGETS foo bar DESTINATION bin OPTIONAL blub) +# +# After the cmake_parse_arguments() call the macro will have set the following +# variables: +# MY_INSTALL_OPTIONAL = TRUE +# MY_INSTALL_FAST = FALSE (this option was not used when calling my_install() +# MY_INSTALL_DESTINATION = "bin" +# MY_INSTALL_RENAME = "" (was not used) +# MY_INSTALL_TARGETS = "foo;bar" +# MY_INSTALL_CONFIGURATIONS = "" (was not used) +# MY_INSTALL_UNPARSED_ARGUMENTS = "blub" (no value expected after "OPTIONAL" +# +# You can the continue and process these variables. +# +# Keywords terminate lists of values, e.g. if directly after a one_value_keyword +# another recognized keyword follows, this is interpreted as the beginning of +# the new option. +# E.g. my_install(TARGETS foo DESTINATION OPTIONAL) would result in +# MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION would +# be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefor. + +#============================================================================= +# Copyright 2010 Alexander Neundorf <neundorf@kde.org> +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * The names of Kitware, Inc., the Insight Consortium, or the names of +# any consortium members, or of any contributors, may not be used to +# endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +#============================================================================= + + +if(__CMAKE_PARSE_ARGUMENTS_INCLUDED) + return() +endif() +set(__CMAKE_PARSE_ARGUMENTS_INCLUDED TRUE) + + +function(CMAKE_PARSE_ARGUMENTS prefix _optionNames _singleArgNames _multiArgNames) + # first set all result variables to empty/FALSE + foreach(arg_name ${_singleArgNames} ${_multiArgNames}) + set(${prefix}_${arg_name}) + endforeach() + + foreach(option ${_optionNames}) + set(${prefix}_${option} FALSE) + endforeach() + + set(${prefix}_UNPARSED_ARGUMENTS) + + set(insideValues FALSE) + set(currentArgName) + + # now iterate over all arguments and fill the result variables + foreach(currentArg ${ARGN}) + list(FIND _optionNames "${currentArg}" optionIndex) # ... then this marks the end of the arguments belonging to this keyword + list(FIND _singleArgNames "${currentArg}" singleArgIndex) # ... then this marks the end of the arguments belonging to this keyword + list(FIND _multiArgNames "${currentArg}" multiArgIndex) # ... then this marks the end of the arguments belonging to this keyword + + if(${optionIndex} EQUAL -1 AND ${singleArgIndex} EQUAL -1 AND ${multiArgIndex} EQUAL -1) + if(insideValues) + if("${insideValues}" STREQUAL "SINGLE") + set(${prefix}_${currentArgName} ${currentArg}) + set(insideValues FALSE) + elseif("${insideValues}" STREQUAL "MULTI") + list(APPEND ${prefix}_${currentArgName} ${currentArg}) + endif() + else() + list(APPEND ${prefix}_UNPARSED_ARGUMENTS ${currentArg}) + endif() + else() + if(NOT ${optionIndex} EQUAL -1) + set(${prefix}_${currentArg} TRUE) + set(insideValues FALSE) + elseif(NOT ${singleArgIndex} EQUAL -1) + set(currentArgName ${currentArg}) + set(${prefix}_${currentArgName}) + set(insideValues "SINGLE") + elseif(NOT ${multiArgIndex} EQUAL -1) + set(currentArgName ${currentArg}) + set(${prefix}_${currentArgName}) + set(insideValues "MULTI") + endif() + endif() + + endforeach() + + # propagate the result variables to the caller: + foreach(arg_name ${_singleArgNames} ${_multiArgNames} ${_optionNames}) + set(${prefix}_${arg_name} ${${prefix}_${arg_name}} PARENT_SCOPE) + endforeach() + set(${prefix}_UNPARSED_ARGUMENTS ${${prefix}_UNPARSED_ARGUMENTS} PARENT_SCOPE) + +endfunction() diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/CheckDIRSymbolExists.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/CheckDIRSymbolExists.cmake new file mode 100644 index 00000000000..dde6c7f3af8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/CheckDIRSymbolExists.cmake @@ -0,0 +1,105 @@ +# Copyright (c) 2002 Kitware, Inc., Insight Consortium +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * The names of Kitware, Inc., the Insight Consortium, or the names of +# any consortium members, or of any contributors, may not be used to +# endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +# - Check if the DIR symbol exists like in AC_HEADER_DIRENT. +# CHECK_DIRSYMBOL_EXISTS(FILES VARIABLE) +# +# FILES - include files to check +# VARIABLE - variable to return result +# +# This module is a small but important variation on CheckSymbolExists.cmake. +# The symbol always searched for is DIR, and the test programme follows +# the AC_HEADER_DIRENT test programme rather than the CheckSymbolExists.cmake +# test programme which always fails since DIR tends to be typedef'd +# rather than #define'd. +# +# The following variables may be set before calling this macro to +# modify the way the check is run: +# +# CMAKE_REQUIRED_FLAGS = string of compile command line flags +# CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar) +# CMAKE_REQUIRED_INCLUDES = list of include directories +# CMAKE_REQUIRED_LIBRARIES = list of libraries to link + +MACRO(CHECK_DIRSYMBOL_EXISTS FILES VARIABLE) + IF(NOT DEFINED ${VARIABLE}) + SET(CMAKE_CONFIGURABLE_FILE_CONTENT "/* */\n") + SET(MACRO_CHECK_DIRSYMBOL_EXISTS_FLAGS ${CMAKE_REQUIRED_FLAGS}) + IF(CMAKE_REQUIRED_LIBRARIES) + SET(CHECK_DIRSYMBOL_EXISTS_LIBS + "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}") + ELSE(CMAKE_REQUIRED_LIBRARIES) + SET(CHECK_DIRSYMBOL_EXISTS_LIBS) + ENDIF(CMAKE_REQUIRED_LIBRARIES) + IF(CMAKE_REQUIRED_INCLUDES) + SET(CMAKE_DIRSYMBOL_EXISTS_INCLUDES + "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}") + ELSE(CMAKE_REQUIRED_INCLUDES) + SET(CMAKE_DIRSYMBOL_EXISTS_INCLUDES) + ENDIF(CMAKE_REQUIRED_INCLUDES) + FOREACH(FILE ${FILES}) + SET(CMAKE_CONFIGURABLE_FILE_CONTENT + "${CMAKE_CONFIGURABLE_FILE_CONTENT}#include <${FILE}>\n") + ENDFOREACH(FILE) + SET(CMAKE_CONFIGURABLE_FILE_CONTENT + "${CMAKE_CONFIGURABLE_FILE_CONTENT}\nint main()\n{if ((DIR *) 0) return 0;}\n") + + CONFIGURE_FILE("${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in" + "${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/CheckDIRSymbolExists.c" @ONLY) + + MESSAGE(STATUS "Looking for DIR in ${FILES}") + TRY_COMPILE(${VARIABLE} + ${CMAKE_BINARY_DIR} + ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/CheckDIRSymbolExists.c + COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} + CMAKE_FLAGS + -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_DIRSYMBOL_EXISTS_FLAGS} + "${CHECK_DIRSYMBOL_EXISTS_LIBS}" + "${CMAKE_DIRSYMBOL_EXISTS_INCLUDES}" + OUTPUT_VARIABLE OUTPUT) + IF(${VARIABLE}) + MESSAGE(STATUS "Looking for DIR in ${FILES} - found") + SET(${VARIABLE} 1 CACHE INTERNAL "Have symbol DIR") + FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log + "Determining if the DIR symbol is defined as in AC_HEADER_DIRENT " + "passed with the following output:\n" + "${OUTPUT}\nFile ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/CheckDIRSymbolExists.c:\n" + "${CMAKE_CONFIGURABLE_FILE_CONTENT}\n") + ELSE(${VARIABLE}) + MESSAGE(STATUS "Looking for DIR in ${FILES} - not found.") + SET(${VARIABLE} "" CACHE INTERNAL "Have symbol DIR") + FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log + "Determining if the DIR symbol is defined as in AC_HEADER_DIRENT " + "failed with the following output:\n" + "${OUTPUT}\nFile ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/CheckDIRSymbolExists.c:\n" + "${CMAKE_CONFIGURABLE_FILE_CONTENT}\n") + ENDIF(${VARIABLE}) + ENDIF(NOT DEFINED ${VARIABLE}) +ENDMACRO(CHECK_DIRSYMBOL_EXISTS) diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/CheckPrototypeExists.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/CheckPrototypeExists.cmake new file mode 100644 index 00000000000..85a171758bc --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/CheckPrototypeExists.cmake @@ -0,0 +1,69 @@ +#============================================================================= +# Copyright 2010 Alexander Neundorf <neundorf@kde.org> +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * The names of Kitware, Inc., the Insight Consortium, or the names of +# any consortium members, or of any contributors, may not be used to +# endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +#============================================================================= + +# AWI, downloaded from KDE repository since has not yet been transferred +# to cmake repository as of 2006-07-31. +# http://websvn.kde.org/trunk/KDE/kdelibs/cmake/modules/CheckPrototypeExists.cmake?rev=505849&view=markup +# +# - Check if the prototype for a function exists. +# CHECK_PROTOTYPE_EXISTS (FUNCTION HEADER VARIABLE) +# +# FUNCTION - the name of the function you are looking for +# HEADER - the header(s) where the prototype should be declared +# VARIABLE - variable to store the result +# + +INCLUDE(CheckCXXSourceCompiles) + +MACRO(CHECK_PROTOTYPE_EXISTS _SYMBOL _HEADER _RESULT) + SET(_INCLUDE_FILES) + FOREACH(it ${_HEADER}) + SET(_INCLUDE_FILES "${_INCLUDE_FILES}#include <${it}>\n") + ENDFOREACH(it) + + SET(_CHECK_PROTO_EXISTS_SOURCE_CODE " +${_INCLUDE_FILES} +void cmakeRequireSymbol(int dummy,...){(void)dummy;} +int main() +{ +#ifndef ${_SYMBOL} +#ifndef _MSC_VER + cmakeRequireSymbol(0,&${_SYMBOL}); +#else + char i = sizeof(&${_SYMBOL}); +#endif +#endif + return 0; +} +") + CHECK_CXX_SOURCE_COMPILES("${_CHECK_PROTO_EXISTS_SOURCE_CODE}" ${_RESULT}) +ENDMACRO(CHECK_PROTOTYPE_EXISTS _SYMBOL _HEADER _RESULT) + diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindFontConfig.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindFontConfig.cmake new file mode 100644 index 00000000000..23d0020c52e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindFontConfig.cmake @@ -0,0 +1,71 @@ +# Copyright (c) 2006,2007 Laurent Montel, <montel@kde.org> +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# 3. The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +# - Try to find Fontconfig +# Once done this will define +# +# FONTCONFIG_FOUND - system has Fontconfig +# FONTCONFIG_INCLUDE_DIR - the Fontconfig include directory +# FONTCONFIG_LIBRARY - Link these to use Fontconfig + +if ( FONTCONFIG_INCLUDE_DIR AND FONTCONFIG_LIBRARY ) + # in cache already + SET(Fontconfig_FIND_QUIETLY TRUE) +endif ( FONTCONFIG_INCLUDE_DIR AND FONTCONFIG_LIBRARY ) + +# use pkg-config to get the directories and then use these values +# in the FIND_PATH() and FIND_LIBRARY() calls +if( NOT WIN32 ) + find_package(PkgConfig) + + pkg_check_modules(FONTCONFIG_PKG QUIET fontconfig) +endif( NOT WIN32 ) + +FIND_PATH(FONTCONFIG_INCLUDE_DIR NAMES fontconfig/fontconfig.h + PATHS + /usr/local/include + /usr/X11/include + /usr/include + HINTS + ${FONTCONFIG_PKG_INCLUDE_DIRS} # Generated by pkg-config +) + +FIND_LIBRARY(FONTCONFIG_LIBRARY NAMES fontconfig ${FONTCONFIG_PKG_LIBRARY} + PATHS + /usr/local + /usr/X11 + /usr + HINTS + ${FONTCONFIG_PKG_LIBRARY_DIRS} # Generated by pkg-config + PATH_SUFFIXES + lib64 + lib +) + +include(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(Fontconfig DEFAULT_MSG FONTCONFIG_LIBRARY FONTCONFIG_INCLUDE_DIR ) + +# show the FONTCONFIG_INCLUDE_DIR and FONTCONFIG_LIBRARY variables only in the advanced view +MARK_AS_ADVANCED(FONTCONFIG_INCLUDE_DIR FONTCONFIG_LIBRARY ) diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindFreetype.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindFreetype.cmake new file mode 100644 index 00000000000..3d2a8a48088 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindFreetype.cmake @@ -0,0 +1,128 @@ +# - Locate FreeType library +# This module defines +# FREETYPE_LIBRARIES, the library to link against +# FREETYPE_FOUND, if false, do not try to link to FREETYPE +# FREETYPE_INCLUDE_DIRS, where to find headers. +# FREETYPE_VERSION_STRING, the version of freetype found (since CMake 2.8.8) +# This is the concatenation of the paths: +# FREETYPE_INCLUDE_DIR_ft2build +# FREETYPE_INCLUDE_DIR_freetype2 +# +# $FREETYPE_DIR is an environment variable that would +# correspond to the ./configure --prefix=$FREETYPE_DIR +# used in building FREETYPE. + +#============================================================================= +# Copyright 2007-2009 Kitware, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * The names of Kitware, Inc., the Insight Consortium, or the names of +# any consortium members, or of any contributors, may not be used to +# endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +# Created by Eric Wing. +# Modifications by Alexander Neundorf. +# This file has been renamed to "FindFreetype.cmake" instead of the correct +# "FindFreeType.cmake" in order to be compatible with the one from KDE4, Alex. + +# Ugh, FreeType seems to use some #include trickery which +# makes this harder than it should be. It looks like they +# put ft2build.h in a common/easier-to-find location which +# then contains a #include to a more specific header in a +# more specific location (#include <freetype/config/ftheader.h>). +# Then from there, they need to set a bunch of #define's +# so you can do something like: +# #include FT_FREETYPE_H +# Unfortunately, using CMake's mechanisms like include_directories() +# wants explicit full paths and this trickery doesn't work too well. +# I'm going to attempt to cut out the middleman and hope +# everything still works. +find_path(FREETYPE_INCLUDE_DIR_ft2build ft2build.h + HINTS + ENV FREETYPE_DIR + PATHS + /usr/local/X11R6 + /usr/local/X11 + /usr/freeware + PATH_SUFFIXES include/freetype2 include +) + +find_path(FREETYPE_INCLUDE_DIR_freetype2 freetype/config/ftheader.h + HINTS + ENV FREETYPE_DIR + PATHS + /usr/local/X11R6 + /usr/local/X11 + /usr/freeware + PATH_SUFFIXES include/freetype2 include +) + +find_library(FREETYPE_LIBRARY + NAMES freetype libfreetype freetype219 freetype_a + HINTS + ENV FREETYPE_DIR + PATH_SUFFIXES lib + PATHS + /usr/local/X11R6 + /usr/local/X11 + /usr/freeware +) + +# set the user variables +if(FREETYPE_INCLUDE_DIR_ft2build AND FREETYPE_INCLUDE_DIR_freetype2) + set(FREETYPE_INCLUDE_DIRS "${FREETYPE_INCLUDE_DIR_ft2build};${FREETYPE_INCLUDE_DIR_freetype2}") +endif() +set(FREETYPE_LIBRARIES "${FREETYPE_LIBRARY}") + +if(FREETYPE_INCLUDE_DIR_freetype2 AND EXISTS "${FREETYPE_INCLUDE_DIR_freetype2}/freetype/freetype.h") + file(STRINGS "${FREETYPE_INCLUDE_DIR_freetype2}/freetype/freetype.h" freetype_version_str + REGEX "^#[\t ]*define[\t ]+FREETYPE_(MAJOR|MINOR|PATCH)[\t ]+[0-9]+$") + + unset(FREETYPE_VERSION_STRING) + foreach(VPART MAJOR MINOR PATCH) + foreach(VLINE ${freetype_version_str}) + if(VLINE MATCHES "^#[\t ]*define[\t ]+FREETYPE_${VPART}") + string(REGEX REPLACE "^#[\t ]*define[\t ]+FREETYPE_${VPART}[\t ]+([0-9]+)$" "\\1" + FREETYPE_VERSION_PART "${VLINE}") + if(FREETYPE_VERSION_STRING) + set(FREETYPE_VERSION_STRING "${FREETYPE_VERSION_STRING}.${FREETYPE_VERSION_PART}") + else() + set(FREETYPE_VERSION_STRING "${FREETYPE_VERSION_PART}") + endif() + unset(FREETYPE_VERSION_PART) + endif() + endforeach() + endforeach() +endif() + + +# handle the QUIETLY and REQUIRED arguments and set FREETYPE_FOUND to TRUE if +# all listed variables are TRUE +include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(Freetype + REQUIRED_VARS FREETYPE_LIBRARY FREETYPE_INCLUDE_DIRS + VERSION_VAR FREETYPE_VERSION_STRING) + +mark_as_advanced(FREETYPE_LIBRARY FREETYPE_INCLUDE_DIR_freetype2 FREETYPE_INCLUDE_DIR_ft2build) diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindGD.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindGD.cmake new file mode 100644 index 00000000000..2860d6cc77f --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindGD.cmake @@ -0,0 +1,121 @@ +# - Find GD +# Find the native GD includes and library +# This module defines +# GD_INCLUDE_DIR, where to find gd.h, etc. +# GD_LIBRARIES, the libraries needed to use GD. +# GD_FOUND, If false, do not try to use GD. +# also defined, but not for general use are +# GD_LIBRARY, where to find the GD library. +# GD_SUPPORTS_PNG, GD_SUPPORTS_JPEG, GD_SUPPORTS_GIF, test +# support for image formats in GD. + +FIND_PATH(GD_INCLUDE_DIR gd.h +/usr/local/include +/usr/include +) + +if(WIN32 AND NOT CYGWIN) + SET(GD_NAMES ${GD_NAMES} bgd) +else(WIN32) + SET(GD_NAMES ${GD_NAMES} gd) +endif(WIN32 AND NOT CYGWIN) + +FIND_LIBRARY(GD_LIBRARY + NAMES ${GD_NAMES} + PATHS /usr/lib64 /usr/lib /usr/local/lib + ) + +IF (GD_LIBRARY AND GD_INCLUDE_DIR) + SET(GD_LIBRARIES ${GD_LIBRARY}) + SET(GD_FOUND "YES") +ELSE (GD_LIBRARY AND GD_INCLUDE_DIR) + SET(GD_FOUND "NO") +ENDIF (GD_LIBRARY AND GD_INCLUDE_DIR) +message("Found GD: ${GD_FOUND}") +IF (GD_FOUND) + IF (WIN32 AND NOT CYGWIN) + SET(GD_SUPPORTS_PNG ON) + SET(GD_SUPPORTS_JPEG ON) + SET(GD_SUPPORTS_GIF ON) + get_filename_component(GD_LIBRARY_DIR ${GD_LIBRARY} PATH) + ELSE (WIN32 AND NOT CYGWIN) + INCLUDE(CheckLibraryExists) + GET_FILENAME_COMPONENT(GD_LIB_PATH ${GD_LIBRARY} PATH) + GET_FILENAME_COMPONENT(GD_LIB ${GD_LIBRARY} NAME) + + CHECK_LIBRARY_EXISTS("${GD_LIBRARY}" "gdImagePng" "${GD_LIB_PATH}" GD_SUPPORTS_PNG) + IF (GD_SUPPORTS_PNG) + find_package(PNG) + IF (PNG_FOUND) + SET(GD_LIBRARIES ${GD_LIBRARIES} ${PNG_LIBRARIES}) + SET(GD_INCLUDE_DIR ${GD_INCLUDE_DIR} ${PNG_INCLUDE_DIR}) + ELSE (PNG_FOUND) + SET(GD_SUPPORTS_PNG "NO") + ENDIF (PNG_FOUND) + ENDIF (GD_SUPPORTS_PNG) + + CHECK_LIBRARY_EXISTS("${GD_LIBRARY}" "gdImageJpeg" "${GD_LIB_PATH}" GD_SUPPORTS_JPEG) + IF (GD_SUPPORTS_JPEG) + find_package(JPEG) + IF (JPEG_FOUND) + SET(GD_LIBRARIES ${GD_LIBRARIES} ${JPEG_LIBRARIES}) + SET(GD_INCLUDE_DIR ${GD_INCLUDE_DIR} ${JPEG_INCLUDE_DIR}) + ELSE (JPEG_FOUND) + SET(GD_SUPPORTS_JPEG "NO") + ENDIF (JPEG_FOUND) + ENDIF (GD_SUPPORTS_JPEG) + + CHECK_LIBRARY_EXISTS("${GD_LIBRARY}" "gdImageGif" "${GD_LIB_PATH}" GD_SUPPORTS_GIF) + + # Trim the list of include directories + SET(GDINCTRIM) + FOREACH(GD_DIR ${GD_INCLUDE_DIR}) + SET(GD_TMP_FOUND OFF) + FOREACH(GD_TRIMMED ${GDINCTRIM}) + IF ("${GD_DIR}" STREQUAL "${GD_TRIMMED}") + SET(GD_TMP_FOUND ON) + ENDIF ("${GD_DIR}" STREQUAL "${GD_TRIMMED}") + ENDFOREACH(GD_TRIMMED ${GDINCTRIM}) + IF (NOT GD_TMP_FOUND) + SET(GDINCTRIM "${GDINCTRIM}" "${GD_DIR}") + ENDIF (NOT GD_TMP_FOUND) + ENDFOREACH(GD_DIR ${GD_INCLUDE_DIR}) + SET(GD_INCLUDE_DIR ${GDINCTRIM}) + + SET(GD_LIBRARY_DIR) + + # Generate trimmed list of library directories and list of libraries + FOREACH(GD_LIB ${GD_LIBRARIES}) + GET_FILENAME_COMPONENT(GD_NEXTLIBDIR ${GD_LIB} PATH) + SET(GD_TMP_FOUND OFF) + FOREACH(GD_LIBDIR ${GD_LIBRARY_DIR}) + IF ("${GD_NEXTLIBDIR}" STREQUAL "${GD_LIBDIR}") + SET(GD_TMP_FOUND ON) + ENDIF ("${GD_NEXTLIBDIR}" STREQUAL "${GD_LIBDIR}") + ENDFOREACH(GD_LIBDIR ${GD_LIBRARIES}) + IF (NOT GD_TMP_FOUND) + SET(GD_LIBRARY_DIR "${GD_LIBRARY_DIR}" "${GD_NEXTLIBDIR}") + ENDIF (NOT GD_TMP_FOUND) + ENDFOREACH(GD_LIB ${GD_LIBRARIES}) + ENDIF (WIN32 AND NOT CYGWIN) +ENDIF (GD_FOUND) + +IF (GD_FOUND) + IF (NOT GD_FIND_QUIETLY) + MESSAGE(STATUS "Found GD: ${GD_LIBRARY}") + ENDIF (NOT GD_FIND_QUIETLY) +ELSE (GD_FOUND) + IF (GD_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find GD library") + ENDIF (GD_FIND_REQUIRED) +ENDIF (GD_FOUND) + +MARK_AS_ADVANCED( + GD_LIBRARY + GD_LIBRARIES + GD_INCLUDE_DIR + GD_LIBRARY_DIR + GD_SUPPORTS_PNG + GD_SUPPORTS_JPEG + GD_SUPPORTS_GIF +) diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindICONV.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindICONV.cmake new file mode 100644 index 00000000000..49d5f6b95a0 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindICONV.cmake @@ -0,0 +1,64 @@ +# - Try to find Iconv +# Once done this will define +# +# ICONV_FOUND - system has Iconv +# ICONV_INCLUDE_DIR - the Iconv include directory +# ICONV_LIBRARIES - Link these to use Iconv +# ICONV_SECOND_ARGUMENT_IS_CONST - the second argument for iconv() is const +# +include(CheckCCompilerFlag) +include(CheckCSourceCompiles) + +IF (ICONV_INCLUDE_DIR AND ICONV_LIBRARIES) + # Already in cache, be silent + SET(ICONV_FIND_QUIETLY TRUE) +ENDIF (ICONV_INCLUDE_DIR AND ICONV_LIBRARIES) + +FIND_PATH(ICONV_INCLUDE_DIR iconv.h HINTS /sw/include/ PATHS /opt/local) + +FIND_LIBRARY(ICONV_LIBRARIES NAMES libiconv_a iconv libiconv c PATHS /opt/local) + +IF(ICONV_INCLUDE_DIR AND ICONV_LIBRARIES) + SET(ICONV_FOUND TRUE) +ENDIF(ICONV_INCLUDE_DIR AND ICONV_LIBRARIES) + +set(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR}) +set(CMAKE_REQUIRED_LIBRARIES ${ICONV_LIBRARIES}) +IF(ICONV_FOUND) + check_c_compiler_flag("-Werror" ICONV_HAVE_WERROR) + set (CMAKE_C_FLAGS_BACKUP "${CMAKE_C_FLAGS}") + if(ICONV_HAVE_WERROR) + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror") + endif(ICONV_HAVE_WERROR) + check_c_source_compiles(" + #include <iconv.h> + int main(){ + iconv_t conv = 0; + const char* in = 0; + size_t ilen = 0; + char* out = 0; + size_t olen = 0; + iconv(conv, &in, &ilen, &out, &olen); + return 0; + } +" ICONV_SECOND_ARGUMENT_IS_CONST ) + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS_BACKUP}") +ENDIF(ICONV_FOUND) +set(CMAKE_REQUIRED_INCLUDES) +set(CMAKE_REQUIRED_LIBRARIES) + +IF(ICONV_FOUND) + IF(NOT ICONV_FIND_QUIETLY) + MESSAGE(STATUS "Found Iconv: ${ICONV_LIBRARIES}") + ENDIF(NOT ICONV_FIND_QUIETLY) +ELSE(ICONV_FOUND) + IF(Iconv_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find Iconv") + ENDIF(Iconv_FIND_REQUIRED) +ENDIF(ICONV_FOUND) + +MARK_AS_ADVANCED( + ICONV_INCLUDE_DIR + ICONV_LIBRARIES + ICONV_SECOND_ARGUMENT_IS_CONST +)
\ No newline at end of file diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindJPEG.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindJPEG.cmake new file mode 100644 index 00000000000..bb310d65dcb --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindJPEG.cmake @@ -0,0 +1,60 @@ +# - Find JPEG +# Find the native JPEG includes and library +# This module defines +# JPEG_INCLUDE_DIR, where to find jpeglib.h, etc. +# JPEG_LIBRARIES, the libraries needed to use JPEG. +# JPEG_FOUND, If false, do not try to use JPEG. +# also defined, but not for general use are +# JPEG_LIBRARY, where to find the JPEG library. + +#============================================================================= +# Copyright 2001-2009 Kitware, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * The names of Kitware, Inc., the Insight Consortium, or the names of +# any consortium members, or of any contributors, may not be used to +# endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +find_path(JPEG_INCLUDE_DIR jpeglib.h) + +set(JPEG_NAMES ${JPEG_NAMES} jpeg libjpeg_a) +find_library(JPEG_LIBRARY NAMES ${JPEG_NAMES} ) + +# handle the QUIETLY and REQUIRED arguments and set JPEG_FOUND to TRUE if +# all listed variables are TRUE +include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(JPEG DEFAULT_MSG JPEG_LIBRARY JPEG_INCLUDE_DIR) + +if(JPEG_FOUND) + set(JPEG_LIBRARIES ${JPEG_LIBRARY}) +endif() + +# Deprecated declarations. +set (NATIVE_JPEG_INCLUDE_PATH ${JPEG_INCLUDE_DIR} ) +if(JPEG_LIBRARY) + get_filename_component (NATIVE_JPEG_LIB_PATH ${JPEG_LIBRARY} PATH) +endif() + +mark_as_advanced(JPEG_LIBRARY JPEG_INCLUDE_DIR ) diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindLIQ.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindLIQ.cmake new file mode 100644 index 00000000000..08713f51704 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindLIQ.cmake @@ -0,0 +1,59 @@ +# Find libimagequant includes and library (and download+build if needed) +# http://pngquant.org/lib +# +# This module defines +# LIQ_INCLUDE_DIR, where to find libimagequant.h +# LIQ_LIBRARIES, the libraries to link against to use libimagequant. +# LIQ_FOUND, If false, do not try to use libimagequant. + +SET(LIQ_FOUND "NO") + +FIND_PATH(LIQ_INCLUDE_DIR libimagequant.h +"${PROJECT_SOURCE_DIR}/libimagequant" +"${PROJECT_SOURCE_DIR}/pngquant/lib" +/usr/local/include +/usr/include +) + +FIND_LIBRARY(LIQ_LIBRARY + NAMES libimagequant imagequant + PATHS "${PROJECT_SOURCE_DIR}/libimagequant" "${PROJECT_SOURCE_DIR}/pngquant/lib" /usr/lib64 /usr/lib /usr/local/lib +) + +IF (LIQ_LIBRARY AND LIQ_INCLUDE_DIR) + SET(LIQ_FOUND "YES") + SET(LIQ_LIBRARIES ${LIQ_LIBRARY}) + SET(HAVE_LIBIMAGEQUANT_H 1) +ENDIF (LIQ_LIBRARY AND LIQ_INCLUDE_DIR) + +IF (LIQ_FOUND) + IF (NOT LIQ_FIND_QUIETLY) + MESSAGE(STATUS "Found LIQ: ${LIQ_LIBRARY} ${LIQ_INCLUDE_DIR}") + ENDIF (NOT LIQ_FIND_QUIETLY) +ELSE (LIQ_FOUND) + # if existing library not found, then download and build it + IF (NOT WIN32 OR CYGWIN OR MINGW) # MSVC's C compiler is too old to compile libimagequant + IF (CMAKE_VERSION VERSION_GREATER "2.8.1") + MESSAGE(STATUS "LIQ will be built") + INCLUDE(ExternalProject) + EXTERNALPROJECT_ADD( + libimagequant + URL "http://pngquant.org/libimagequant-2.0.0-src.tar.bz2" + SOURCE_DIR libimagequant + BUILD_IN_SOURCE 1 + INSTALL_DIR libimagequant + INSTALL_COMMAND true + CONFIGURE_COMMAND true + BUILD_COMMAND make static CFLAGSADD='-fPIC' + ) + + SET(LIQ_FOUND "SORTOF") + SET(LIQ_BUILD "YES") + SET(LIQ_LIBRARIES "${PROJECT_BINARY_DIR}/libimagequant/libimagequant.a") + SET(LIQ_INCLUDE_DIR "${PROJECT_BINARY_DIR}/libimagequant/") + SET(HAVE_LIBIMAGEQUANT_H 1) + ENDIF(CMAKE_VERSION VERSION_GREATER "2.8.1") + ENDIF(NOT WIN32 OR CYGWIN OR MINGW) +ENDIF (LIQ_FOUND) + +MARK_AS_ADVANCED(LIQ_INCLUDE_DIR LIQ_LIBRARIES LIQ_BUILD) diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindPNG.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindPNG.cmake new file mode 100644 index 00000000000..a44affcfcc0 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindPNG.cmake @@ -0,0 +1,93 @@ +# - Find the native PNG includes and library +# +# This module searches libpng, the library for working with PNG images. +# +# It defines the following variables +# PNG_INCLUDE_DIRS, where to find png.h, etc. +# PNG_LIBRARIES, the libraries to link against to use PNG. +# PNG_DEFINITIONS - You should add_definitons(${PNG_DEFINITIONS}) before compiling code that includes png library files. +# PNG_FOUND, If false, do not try to use PNG. +# PNG_VERSION_STRING - the version of the PNG library found (since CMake 2.8.8) +# Also defined, but not for general use are +# PNG_LIBRARY, where to find the PNG library. +# For backward compatiblity the variable PNG_INCLUDE_DIR is also set. It has the same value as PNG_INCLUDE_DIRS. +# +# Since PNG depends on the ZLib compression library, none of the above will be +# defined unless ZLib can be found. + +#============================================================================= +# Copyright 2002-2009 Kitware, Inc. +# +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * The names of Kitware, Inc., the Insight Consortium, or the names of +# any consortium members, or of any contributors, may not be used to +# endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +if(PNG_FIND_QUIETLY) + set(_FIND_ZLIB_ARG QUIET) +endif() +find_package(ZLIB ${_FIND_ZLIB_ARG}) + +if(ZLIB_FOUND) + find_path(PNG_PNG_INCLUDE_DIR png.h + /usr/local/include/libpng # OpenBSD + ) + + set(PNG_NAMES ${PNG_NAMES} png libpng png15 libpng15 png15d libpng15d png14 libpng14 png14d libpng14d png12 libpng12 png12d libpng12d libpng_a) + find_library(PNG_LIBRARY NAMES ${PNG_NAMES} ) + + if (PNG_LIBRARY AND PNG_PNG_INCLUDE_DIR) + # png.h includes zlib.h. Sigh. + set(PNG_INCLUDE_DIRS ${PNG_PNG_INCLUDE_DIR} ${ZLIB_INCLUDE_DIR} ) + set(PNG_INCLUDE_DIR ${PNG_INCLUDE_DIRS} ) # for backward compatiblity + set(PNG_LIBRARIES ${PNG_LIBRARY} ${ZLIB_LIBRARY}) + + if (CYGWIN) + if(BUILD_SHARED_LIBS) + # No need to define PNG_USE_DLL here, because it's default for Cygwin. + else() + set (PNG_DEFINITIONS -DPNG_STATIC) + endif() + endif () + + endif () + + if (PNG_PNG_INCLUDE_DIR AND EXISTS "${PNG_PNG_INCLUDE_DIR}/png.h") + file(STRINGS "${PNG_PNG_INCLUDE_DIR}/png.h" png_version_str REGEX "^#define[ \t]+PNG_LIBPNG_VER_STRING[ \t]+\".+\"") + + string(REGEX REPLACE "^#define[ \t]+PNG_LIBPNG_VER_STRING[ \t]+\"([^\"]+)\".*" "\\1" PNG_VERSION_STRING "${png_version_str}") + unset(png_version_str) + endif () +endif() + +# handle the QUIETLY and REQUIRED arguments and set PNG_FOUND to TRUE if +# all listed variables are TRUE +include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake) +find_package_handle_standard_args(PNG + REQUIRED_VARS PNG_LIBRARY PNG_PNG_INCLUDE_DIR + VERSION_VAR PNG_VERSION_STRING) + +mark_as_advanced(PNG_PNG_INCLUDE_DIR PNG_LIBRARY ) diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindPTHREAD.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindPTHREAD.cmake new file mode 100644 index 00000000000..0627c6d0a44 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindPTHREAD.cmake @@ -0,0 +1,92 @@ +#############################################################################
+#
+# $Id: FindPTHREAD.cmake 4056 2013-01-05 13:04:42Z fspindle $
+#
+# This file is part of the ViSP software.
+# Copyright (C) 2005 - 2013 by INRIA. All rights reserved.
+#
+# This software is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# ("GPL") version 2 as published by the Free Software Foundation.
+# See the file LICENSE.txt at the root directory of this source
+# distribution for additional information about the GNU GPL.
+#
+# For using ViSP with software that can not be combined with the GNU
+# GPL, please contact INRIA about acquiring a ViSP Professional
+# Edition License.
+#
+# See http://www.irisa.fr/lagadic/visp/visp.html for more information.
+#
+# This software was developed at:
+# INRIA Rennes - Bretagne Atlantique
+# Campus Universitaire de Beaulieu
+# 35042 Rennes Cedex
+# France
+# http://www.irisa.fr/lagadic
+#
+# If you have questions regarding the use of this file, please contact
+# INRIA at visp@inria.fr
+#
+# This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+# WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+#
+# Description:
+# Try to find pthread library.
+# Once run this will define:
+#
+# PTHREAD_FOUND
+# PTHREAD_INCLUDE_DIRS
+# PTHREAD_LIBRARIES
+#
+# Authors:
+# Fabien Spindler
+#
+#############################################################################
+
+
+ FIND_PATH(PTHREAD_INCLUDE_DIR pthread.h
+ "$ENV{PTHREAD_HOME}/include"
+ "$ENV{PTHREAD_DIR}/include"
+ /usr/include
+ "C:/MinGW/include"
+ )
+ #MESSAGE("DBG PTHREAD_INCLUDE_DIR=${PTHREAD_INCLUDE_DIR}")
+
+ # pthreadVSE pthreadGCE pthreadGC pthreadVC1 pthreadVC2 are comming from web
+ FIND_LIBRARY(PTHREAD_LIBRARY
+ NAMES pthread pthreadGC2 pthreadVSE pthreadGCE pthreadGC pthreadVC1 pthreadVC2
+ PATHS
+ "$ENV{PTHREAD_HOME}/lib"
+ "$ENV{PTHREAD_DIR}/lib"
+ /usr/lib
+ /usr/local/lib
+ /lib
+ "C:/MinGW/lib"
+ )
+
+ #MESSAGE(STATUS "DBG PTHREAD_LIBRARY=${PTHREAD_LIBRARY}")
+
+ ## --------------------------------
+
+ IF(PTHREAD_LIBRARY)
+ SET(PTHREAD_LIBRARIES ${PTHREAD_LIBRARY})
+ ELSE(PTHREAD_LIBRARY)
+ #MESSAGE(SEND_ERROR "pthread library not found.")
+ ENDIF(PTHREAD_LIBRARY)
+
+ IF(NOT PTHREAD_INCLUDE_DIR)
+ #MESSAGE(SEND_ERROR "pthread include dir not found.")
+ ENDIF(NOT PTHREAD_INCLUDE_DIR)
+
+ IF(PTHREAD_LIBRARIES AND PTHREAD_INCLUDE_DIR)
+ SET(PTHREAD_INCLUDE_DIRS ${PTHREAD_INCLUDE_DIR})
+ SET(PTHREAD_FOUND TRUE)
+ ELSE(PTHREAD_LIBRARIES AND PTHREAD_INCLUDE_DIR)
+ SET(PTHREAD_FOUND FALSE)
+ ENDIF(PTHREAD_LIBRARIES AND PTHREAD_INCLUDE_DIR)
+
+ MARK_AS_ADVANCED(
+ PTHREAD_INCLUDE_DIR
+ PTHREAD_LIBRARY
+ )
+ #MESSAGE(STATUS "PTHREAD_FOUND : ${PTHREAD_FOUND}")
diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindPackageHandleStandardArgs.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindPackageHandleStandardArgs.cmake new file mode 100644 index 00000000000..de124acce43 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindPackageHandleStandardArgs.cmake @@ -0,0 +1,317 @@ +# FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name> ... ) +# +# This function is intended to be used in FindXXX.cmake modules files. +# It handles the REQUIRED, QUIET and version-related arguments to find_package(). +# It also sets the <UPPERCASED_NAME>_FOUND variable. +# The package is considered found if all variables <var1>... listed contain +# valid results, e.g. valid filepaths. +# +# There are two modes of this function. The first argument in both modes is +# the name of the Find-module where it is called (in original casing). +# +# The first simple mode looks like this: +# FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name> (DEFAULT_MSG|"Custom failure message") <var1>...<varN> ) +# If the variables <var1> to <varN> are all valid, then <UPPERCASED_NAME>_FOUND +# will be set to TRUE. +# If DEFAULT_MSG is given as second argument, then the function will generate +# itself useful success and error messages. You can also supply a custom error message +# for the failure case. This is not recommended. +# +# The second mode is more powerful and also supports version checking: +# FIND_PACKAGE_HANDLE_STANDARD_ARGS(NAME [REQUIRED_VARS <var1>...<varN>] +# [VERSION_VAR <versionvar>] +# [HANDLE_COMPONENTS] +# [CONFIG_MODE] +# [FAIL_MESSAGE "Custom failure message"] ) +# +# As above, if <var1> through <varN> are all valid, <UPPERCASED_NAME>_FOUND +# will be set to TRUE. +# After REQUIRED_VARS the variables which are required for this package are listed. +# Following VERSION_VAR the name of the variable can be specified which holds +# the version of the package which has been found. If this is done, this version +# will be checked against the (potentially) specified required version used +# in the find_package() call. The EXACT keyword is also handled. The default +# messages include information about the required version and the version +# which has been actually found, both if the version is ok or not. +# If the package supports components, use the HANDLE_COMPONENTS option to enable +# handling them. In this case, find_package_handle_standard_args() will report +# which components have been found and which are missing, and the <NAME>_FOUND +# variable will be set to FALSE if any of the required components (i.e. not the +# ones listed after OPTIONAL_COMPONENTS) are missing. +# Use the option CONFIG_MODE if your FindXXX.cmake module is a wrapper for +# a find_package(... NO_MODULE) call. In this case VERSION_VAR will be set +# to <NAME>_VERSION and the macro will automatically check whether the +# Config module was found. +# Via FAIL_MESSAGE a custom failure message can be specified, if this is not +# used, the default message will be displayed. +# +# Example for mode 1: +# +# FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibXml2 DEFAULT_MSG LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR) +# +# LibXml2 is considered to be found, if both LIBXML2_LIBRARY and +# LIBXML2_INCLUDE_DIR are valid. Then also LIBXML2_FOUND is set to TRUE. +# If it is not found and REQUIRED was used, it fails with FATAL_ERROR, +# independent whether QUIET was used or not. +# If it is found, success will be reported, including the content of <var1>. +# On repeated Cmake runs, the same message won't be printed again. +# +# Example for mode 2: +# +# FIND_PACKAGE_HANDLE_STANDARD_ARGS(BISON REQUIRED_VARS BISON_EXECUTABLE +# VERSION_VAR BISON_VERSION) +# In this case, BISON is considered to be found if the variable(s) listed +# after REQUIRED_VAR are all valid, i.e. BISON_EXECUTABLE in this case. +# Also the version of BISON will be checked by using the version contained +# in BISON_VERSION. +# Since no FAIL_MESSAGE is given, the default messages will be printed. +# +# Another example for mode 2: +# +# find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4) +# FIND_PACKAGE_HANDLE_STANDARD_ARGS(Automoc4 CONFIG_MODE) +# In this case, FindAutmoc4.cmake wraps a call to find_package(Automoc4 NO_MODULE) +# and adds an additional search directory for automoc4. +# The following FIND_PACKAGE_HANDLE_STANDARD_ARGS() call produces a proper +# success/error message. + +#============================================================================= +# Copyright 2007-2009 Kitware, Inc. +# +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * The names of Kitware, Inc., the Insight Consortium, or the names of +# any consortium members, or of any contributors, may not be used to +# endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +include(FindPackageMessage) +include(CMakeParseArguments) + +# internal helper macro +macro(_FPHSA_FAILURE_MESSAGE _msg) + if (${_NAME}_FIND_REQUIRED) + message(FATAL_ERROR "${_msg}") + else () + if (NOT ${_NAME}_FIND_QUIETLY) + message(STATUS "${_msg}") + endif () + endif () +endmacro() + + +# internal helper macro to generate the failure message when used in CONFIG_MODE: +macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE) + # <name>_CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found: + if(${_NAME}_CONFIG) + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing: ${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})") + else() + # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version. + # List them all in the error message: + if(${_NAME}_CONSIDERED_CONFIGS) + set(configsText "") + list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount) + math(EXPR configsCount "${configsCount} - 1") + foreach(currentConfigIndex RANGE ${configsCount}) + list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename) + list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version) + set(configsText "${configsText} ${filename} (version ${version})\n") + endforeach() + if (${_NAME}_NOT_FOUND_MESSAGE) + set(configsText "${configsText} Reason given by package: ${${_NAME}_NOT_FOUND_MESSAGE}\n") + endif() + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:\n${configsText}") + + else() + # Simple case: No Config-file was found at all: + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}") + endif() + endif() +endmacro() + + +function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG) + +# set up the arguments for CMAKE_PARSE_ARGUMENTS and check whether we are in +# new extended or in the "old" mode: + set(options CONFIG_MODE HANDLE_COMPONENTS) + set(oneValueArgs FAIL_MESSAGE VERSION_VAR) + set(multiValueArgs REQUIRED_VARS) + set(_KEYWORDS_FOR_EXTENDED_MODE ${options} ${oneValueArgs} ${multiValueArgs} ) + list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX) + + if(${INDEX} EQUAL -1) + set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG}) + set(FPHSA_REQUIRED_VARS ${ARGN}) + set(FPHSA_VERSION_VAR) + else() + + CMAKE_PARSE_ARGUMENTS(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}" ${_FIRST_ARG} ${ARGN}) + + if(FPHSA_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"") + endif() + + if(NOT FPHSA_FAIL_MESSAGE) + set(FPHSA_FAIL_MESSAGE "DEFAULT_MSG") + endif() + endif() + +# now that we collected all arguments, process them + + if("${FPHSA_FAIL_MESSAGE}" STREQUAL "DEFAULT_MSG") + set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}") + endif() + + # In config-mode, we rely on the variable <package>_CONFIG, which is set by find_package() + # when it successfully found the config-file, including version checking: + if(FPHSA_CONFIG_MODE) + list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG) + list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS) + set(FPHSA_VERSION_VAR ${_NAME}_VERSION) + endif() + + if(NOT FPHSA_REQUIRED_VARS) + message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()") + endif() + + list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR) + + string(TOUPPER ${_NAME} _NAME_UPPER) + string(TOLOWER ${_NAME} _NAME_LOWER) + + # collect all variables which were not found, so they can be printed, so the + # user knows better what went wrong (#6375) + set(MISSING_VARS "") + set(DETAILS "") + set(${_NAME_UPPER}_FOUND TRUE) + # check if all passed variables are valid + foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS}) + if(NOT ${_CURRENT_VAR}) + set(${_NAME_UPPER}_FOUND FALSE) + set(MISSING_VARS "${MISSING_VARS} ${_CURRENT_VAR}") + else() + set(DETAILS "${DETAILS}[${${_CURRENT_VAR}}]") + endif() + endforeach() + + # component handling + unset(FOUND_COMPONENTS_MSG) + unset(MISSING_COMPONENTS_MSG) + + if(FPHSA_HANDLE_COMPONENTS) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(${_NAME}_${comp}_FOUND) + + if(NOT DEFINED FOUND_COMPONENTS_MSG) + set(FOUND_COMPONENTS_MSG "found components: ") + endif() + set(FOUND_COMPONENTS_MSG "${FOUND_COMPONENTS_MSG} ${comp}") + + else() + + if(NOT DEFINED MISSING_COMPONENTS_MSG) + set(MISSING_COMPONENTS_MSG "missing components: ") + endif() + set(MISSING_COMPONENTS_MSG "${MISSING_COMPONENTS_MSG} ${comp}") + + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME_UPPER}_FOUND FALSE) + set(MISSING_VARS "${MISSING_VARS} ${comp}") + endif() + + endif() + endforeach() + set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}") + set(DETAILS "${DETAILS}[c${COMPONENT_MSG}]") + endif() + + # version handling: + set(VERSION_MSG "") + set(VERSION_OK TRUE) + set(VERSION ${${FPHSA_VERSION_VAR}} ) + if (${_NAME}_FIND_VERSION) + + if(VERSION) + + if(${_NAME}_FIND_VERSION_EXACT) # exact version required + if (NOT "${${_NAME}_FIND_VERSION}" VERSION_EQUAL "${VERSION}") + set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"") + set(VERSION_OK FALSE) + else () + set(VERSION_MSG "(found suitable exact version \"${VERSION}\")") + endif () + + else() # minimum version specified: + if ("${${_NAME}_FIND_VERSION}" VERSION_GREATER "${VERSION}") + set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"") + set(VERSION_OK FALSE) + else () + set(VERSION_MSG "(found suitable version \"${VERSION}\", minimum required is \"${${_NAME}_FIND_VERSION}\")") + endif () + endif() + + else() + + # if the package was not found, but a version was given, add that to the output: + if(${_NAME}_FIND_VERSION_EXACT) + set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")") + else() + set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")") + endif() + + endif() + else () + if(VERSION) + set(VERSION_MSG "(found version \"${VERSION}\")") + endif() + endif () + + if(VERSION_OK) + set(DETAILS "${DETAILS}[v${VERSION}(${${_NAME}_FIND_VERSION})]") + else() + set(${_NAME_UPPER}_FOUND FALSE) + endif() + + + # print the result: + if (${_NAME_UPPER}_FOUND) + FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}") + else () + + if(FPHSA_CONFIG_MODE) + _FPHSA_HANDLE_FAILURE_CONFIG_MODE() + else() + if(NOT VERSION_OK) + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})") + else() + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing: ${MISSING_VARS}) ${VERSION_MSG}") + endif() + endif() + + endif () + + set(${_NAME_UPPER}_FOUND ${${_NAME_UPPER}_FOUND} PARENT_SCOPE) + +endfunction() diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindVPX.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindVPX.cmake new file mode 100644 index 00000000000..3a8c45ed196 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindVPX.cmake @@ -0,0 +1,75 @@ +# - Find the native VPX includes and library +# + +# This module defines +# VPX_INCLUDE_DIR, where to find png.h, etc. +# VPX_LIBRARIES, the libraries to link against to use VPX. +# VPX_DEFINITIONS - You should ADD_DEFINITONS(${VPX_DEFINITIONS}) before compiling code that includes png library files. +# VPX_FOUND, If false, do not try to use VPX. +# also defined, but not for general use are +# VPX_LIBRARY, where to find the VPX library. +# +# Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * The names of Kitware, Inc., the Insight Consortium, or the names of +# any consortium members, or of any contributors, may not be used to +# endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +INCLUDE(FindZLIB) + +SET(VPX_FOUND "NO") +SET(VPX_LIBRARY "") + +FIND_PATH(VPX_INCLUDE_DIR vp8cx.h +/usr/local/include/vpx +/usr/include/vpx +) + +SET(VPX_NAMES ${VPX_NAMES} "vpxmt" "libvpx") +FIND_LIBRARY(VPX_LIBRARY + NAMES ${VPX_NAMES} + PATHS "${PROJECT_SOURCE_DIR}/../deps/lib" /usr/lib64 /usr/lib /usr/local/lib +) + +IF (VPX_LIBRARY AND VPX_INCLUDE_DIR) + SET(VPX_INCLUDE_DIR ${VPX_INCLUDE_DIR}) + SET(VPX_LIBRARIES ${VPX_LIBRARY}) + SET(VPX_FOUND "YES") + +ENDIF (VPX_LIBRARY AND VPX_INCLUDE_DIR) + +IF (VPX_FOUND) + IF (NOT VPX_FIND_QUIETLY) + MESSAGE(STATUS "Found VPX: ${VPX_LIBRARY}") + ENDIF (NOT VPX_FIND_QUIETLY) +ELSE (VPX_FOUND) + IF (VPX_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find VPX library") + ENDIF (VPX_FIND_REQUIRED) +ENDIF (VPX_FOUND) + +MARK_AS_ADVANCED(VPX_INCLUDE_DIR VPX_LIBRARY ) +SET(VPX_LIBRARIES ${VPX_LIBRARY}) diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindXPM.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindXPM.cmake new file mode 100644 index 00000000000..9b59feaa10e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/FindXPM.cmake @@ -0,0 +1,78 @@ +# - Find the native XPM includes and library +# + +# This module defines +# XPM_INCLUDE_DIR, where to find png.h, etc. +# XPM_LIBRARIES, the libraries to link against to use XPM. +# XPM_DEFINITIONS - You should ADD_DEFINITONS(${XPM_DEFINITIONS}) before compiling code that includes png library files. +# XPM_FOUND, If false, do not try to use XPM. +# also defined, but not for general use are +# XPM_LIBRARY, where to find the XPM library. + +# Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * The names of Kitware, Inc., the Insight Consortium, or the names of +# any consortium members, or of any contributors, may not be used to +# endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +SET(XPM_FOUND "NO") + +FIND_PATH(XPM_XPM_INCLUDE_DIR xpm.h +/usr/local/include/X11 +/usr/include/X11 +) + +SET(XPM_NAMES ${XPM_NAMES} Xpm libXpm) +FIND_LIBRARY(XPM_LIBRARY + NAMES ${XPM_NAMES} + PATHS /usr/lib64 /usr/lib /usr/local/lib +) + +IF (XPM_LIBRARY AND XPM_XPM_INCLUDE_DIR) + SET(XPM_INCLUDE_DIR ${XPM_XPM_INCLUDE_DIR}) + SET(XPM_LIBRARIES ${XPM_LIBRARY}) + SET(XPM_FOUND "YES") + + IF (CYGWIN) + IF(BUILD_SHARED_LIBS) + # No need to define XPM_USE_DLL here, because it's default for Cygwin. + ELSE(BUILD_SHARED_LIBS) + SET (XPM_DEFINITIONS -DXPM_STATIC) + ENDIF(BUILD_SHARED_LIBS) + ENDIF (CYGWIN) +ENDIF (XPM_LIBRARY AND XPM_XPM_INCLUDE_DIR) + +IF (XPM_FOUND) + IF (NOT XPM_FIND_QUIETLY) + MESSAGE(STATUS "Found XPM: ${XPM_LIBRARY}") + ENDIF (NOT XPM_FIND_QUIETLY) +ELSE (XPM_FOUND) + IF (XPM_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find XPM library") + ENDIF (XPM_FIND_REQUIRED) +ENDIF (XPM_FOUND) + +MARK_AS_ADVANCED(XPM_XPM_INCLUDE_DIR XPM_LIBRARY ) diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/TestForHighBitCharacters.c b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/TestForHighBitCharacters.c new file mode 100644 index 00000000000..2be51745ac8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/TestForHighBitCharacters.c @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2006 Alan W. Irwin + * + * This file is part of PLplot. + * + * PLplot is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License as published + * by the Free Software Foundation; version 2 of the License. + * + * PLplot is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with the file PLplot; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <ctype.h> +#if ((' ' & 0x0FF) == 0x020) +# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) +#else +# define ISLOWER(c) \ + (('a' <= (c) && (c) <= 'i') \ + || ('j' <= (c) && (c) <= 'r') \ + || ('s' <= (c) && (c) <= 'z')) +# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) +#endif + +#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) +int +main () +{ + int i; + for (i = 0; i < 256; i++) + if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) + exit(1); + exit (0); +} diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/TestForHighBitCharacters.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/TestForHighBitCharacters.cmake new file mode 100644 index 00000000000..b1a1b908223 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/TestForHighBitCharacters.cmake @@ -0,0 +1,45 @@ +# cmake/modules/TestForHighBitCharacters.cmake +# +# Copyright (C) 2006 Alan W. Irwin +# +# This file is part of PLplot. +# +# PLplot is free software; you can redistribute it and/or modify +# it under the terms of the GNU Library General Public License as published +# by the Free Software Foundation; version 2 of the License. +# +# PLplot is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Library General Public License for more details. +# +# You should have received a copy of the GNU Library General Public License +# along with the file PLplot; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +# Check if ctype.h macros work on characters with the high bit set. +if(NOT DEFINED CMAKE_HIGH_BIT_CHARACTERS) + message(STATUS + "Check for whether ctype.h macros work on characters with the\n" + " high bit set." + ) + try_compile(CMAKE_HIGH_BIT_CHARACTERS + ${CMAKE_BINARY_DIR} + ${CMAKE_SOURCE_DIR}/CMakeModules/TestForHighBitCharacters.c + OUTPUT_VARIABLE OUTPUT) + if(CMAKE_HIGH_BIT_CHARACTERS) + message(STATUS "High-bit characters - work") + set(HIGH_BIT_CHARACTERS 1 CACHE INTERNAL + "Do ctype.h macros work on high-bit characters") + file(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log + "Determining if ctype.h macros work on high-bit characters passed with " + "the following output:\n${OUTPUT}\n\n") + else(CMAKE_HIGH_BIT_CHARACTERS) + message(STATUS "High-bit characters - don't work") + set(HIGH_BIT_CHARACTERS 0 CACHE INTERNAL + "Do ctype.h macros work on high-bit characters") + file(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log + "Determining if ctype.h macros work on high-bit characters failed with " + "the following output:\n${OUTPUT}\n\n") + endif(CMAKE_HIGH_BIT_CHARACTERS) +endif(NOT DEFINED CMAKE_HIGH_BIT_CHARACTERS) diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/TestForStandardHeaderwait.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/TestForStandardHeaderwait.cmake new file mode 100644 index 00000000000..d3df427f9c8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/TestForStandardHeaderwait.cmake @@ -0,0 +1,47 @@ +# cmake/modules/CheckHEADER_SYS_WAIT.cmake +# +# Copyright (C) 2006 Alan W. Irwin +# +# This file is part of PLplot. +# +# PLplot is free software; you can redistribute it and/or modify +# it under the terms of the GNU Library General Public License as published +# by the Free Software Foundation; version 2 of the License. +# +# PLplot is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Library General Public License for more details. +# +# You should have received a copy of the GNU Library General Public License +# along with the file PLplot; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +# +# - Check for sys/wait.h that is POSIX.1 compatible following autotools +# AC_HEADER_SYS_WAIT + +include(CheckCSourceCompiles) + +set(_CHECK_HEADER_SYS_WAIT_SOURCE_CODE " +#include <sys/types.h> +#include <sys/wait.h> +#ifndef WEXITSTATUS +# define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8) +#endif +#ifndef WIFEXITED +# define WIFEXITED(stat_val) (((stat_val) & 255) == 0) +#endif +int +main () +{ + int s; + wait (&s); + s = WIFEXITED (s) ? WEXITSTATUS (s) : 1; + ; + return 0; +} +") +check_c_source_compiles( +"${_CHECK_HEADER_SYS_WAIT_SOURCE_CODE}" +HAVE_SYS_WAIT_H) diff --git a/Build/source/libs/gd/libgd-2.1.1/cmake/modules/gd.cmake b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/gd.cmake new file mode 100644 index 00000000000..1e846dd855d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/cmake/modules/gd.cmake @@ -0,0 +1 @@ +option(BUILD_TEST "Compile examples in the build tree and enable ctest" OFF) diff --git a/Build/source/libs/gd/libgd-2.1.1/config/Makefile.am b/Build/source/libs/gd/libgd-2.1.1/config/Makefile.am new file mode 100644 index 00000000000..7ec5849fb68 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/config/Makefile.am @@ -0,0 +1,7 @@ +## Process this file with automake to produce Makefile.in -*-Makefile-*- +EXTRA_DIST = gdlib-config.in gdlib.pc.in + +bin_SCRIPTS = gdlib-config + +pkgconfigdir = $(libdir)/pkgconfig +pkgconfig_DATA = gdlib.pc diff --git a/Build/source/libs/gd/libgd-2.1.1/config/gdlib-config.in b/Build/source/libs/gd/libgd-2.1.1/config/gdlib-config.in new file mode 100644 index 00000000000..70af36b5359 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/config/gdlib-config.in @@ -0,0 +1,96 @@ +#!/bin/sh +# +# Return information about the local GD library installation +# +# Modeled after pdflib-config + +# installation directories +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ +bindir=@bindir@ + +usage() +{ + cat <<EOF +Print information on GD library's version, configuration, and use. +Usage: gdlib-config [options] +Options: + --libdir # directory where GD library is installed + --includedir # directory where GD library headers are installed + --version # complete GD library version string + --majorversion # GD library major version number + --minorversion # GD library minor version number + --revision # GD library revision version number + --ldflags # options required for linking against GD library + --libs # libs required for linking against GD library + --cflags # options required for compiling GD library apps + --includes # same as --cflags + --features # lists features compiled into gd, separated by spaces. + # Currently (as of @VERSION@) the optional features + # are GD_PNG, GD_JPEG, GD_XPM, GD_FREETYPE, and + # GD_FONTCONFIG. When these features are reported by + # --features, it is safe to include calls to the + # related functions in your code. + --all # print a summary of all GD library configure options +EOF + exit $1 +} + +if test $# -eq 0; then + usage 1 1>&2 +fi + +while test $# -gt 0; do + case "$1" in + -*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;; + *) optarg= ;; + esac + + case $1 in + --libdir) + echo $libdir + ;; + --includedir) + echo $includedir + ;; + --version) + echo @VERSION@ + ;; + --majorversion) + echo @GDLIB_MAJOR@ + ;; + --minorversion) + echo @GDLIB_MINOR@ + ;; + --revision) + echo @GDLIB_REVISION@ + ;; + --ldflags) + echo @LDFLAGS@ + ;; + --libs) + echo -lgd @LIBS@ @LIBICONV@ + ;; + --cflags|--includes) + echo -I@includedir@ + ;; + --features) + echo @FEATURES@ + ;; + --all) + echo "GD library @VERSION@" + echo "includedir: $includedir" + echo "cflags: -I@includedir@" + echo "ldflags: @LDFLAGS@" + echo "libs: @LIBS@ @LIBICONV@" + echo "libdir: $libdir" + echo "features: @FEATURES@" + ;; + *) + usage 1 1>&2 + ;; + esac + shift +done diff --git a/Build/source/libs/gd/libgd-2.1.1/config/gdlib.pc.in b/Build/source/libs/gd/libgd-2.1.1/config/gdlib.pc.in new file mode 100644 index 00000000000..b980a606902 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/config/gdlib.pc.in @@ -0,0 +1,11 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: gd +Description: GD graphics library +Version: @VERSION@ +Cflags: -I${includedir} +Libs.private: @LIBS@ @LIBICONV@ +Libs: -L${libdir} -lgd diff --git a/Build/source/libs/gd/libgd-2.1.1/configure.ac b/Build/source/libs/gd/libgd-2.1.1/configure.ac new file mode 100644 index 00000000000..1024a3a5ad6 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/configure.ac @@ -0,0 +1,463 @@ +# Process this file with autoconf to produce a configure script. +# Configure template for gd library + +AC_PREREQ(2.54) + +# We extract version numbers from src/versions.h +define([gv],[perl config/getver.pl ]$1) + +m4_define([gd_MAJOR],esyscmd(gv(MAJOR)))dnl +m4_define([gd_MINOR],esyscmd(gv(MINOR)))dnl +m4_define([gd_REVISION],esyscmd(gv(RELEASE)))dnl +m4_define([gd_EXTRA],esyscmd(gv(EXTRA)))dnl +m4_define([gd_PKG_VERSION],[gd_MAJOR.gd_MINOR.gd_REVISION]gd_EXTRA)]dnl + +AC_INIT([GD], gd_PKG_VERSION, [https://bitbucket.org/libgd/gd-libgd/issues], [libgd], [http://lib.gd]) +AC_CONFIG_SRCDIR([src/gd.c]) +AC_CONFIG_AUX_DIR(config) +AC_CONFIG_MACRO_DIR([m4]) +AC_CANONICAL_HOST + +# This is not used anywhere. However, Makefile.netware searches +# through configure for these definitions to find the version numbers. +# (Assuming anyone still uses Netware, that should be changed to use +# gd.h via getver.pl instead.) +GDLIB_MAJOR=gd_MAJOR +GDLIB_MINOR=gd_MINOR +GDLIB_REVISION=gd_REVISION +GDLIB_EXTRA=gd_EXTRA +GDLIB_VERSION=gd_PKG_VERSION + +# Dynamic library version information +# See http://www.gnu.org/software/libtool/manual/libtool.html#Updating-version-info + +GDLIB_CURRENT=3 +GDLIB_REVISION=0 +GDLIB_AGE=0 +AC_SUBST(GDLIB_CURRENT) +AC_SUBST(GDLIB_REVISION) +AC_SUBST(GDLIB_AGE) + +#Expanded by tests later in this file. TBB 2.0.26 +#2.0.28: GIF is standard now. Doesn't depend on anything else, +#so we always build it. +FEATURES="GD_GIF GD_GIFANIM GD_OPENPOLYGON" +AC_SUBST(FEATURES) + +AM_INIT_AUTOMAKE([foreign dist-bzip2 dist-xz -Wall -Werror subdir-objects]) +AC_CONFIG_HEADERS([src/config.h:src/config.hin]) + +dnl newer automake wants this, but we still want to work with older +m4_ifndef([AM_PROG_AR],[m4_define([AM_PROG_AR],[:])]) +AM_PROG_AR + +AC_PROG_CC_STDC +AM_PROG_CC_C_O +AC_PROG_INSTALL +AC_PROG_LIBTOOL +AC_PROG_LN_S +AC_PROG_MAKE_SET +LT_INIT([win32-dll]) +PKG_PROG_PKG_CONFIG + +dnl may be required for freetype and Xpm +AC_PATH_X + +if test -n "$x_includes" && test "x$x_includes" != xNONE ; then + CFLAGS="$CFLAGS -I$x_includes" +fi +if test -n "$x_libraries" && test "x$x_libraries" != xNONE ; then + LDFLAGS="$LDFLAGS -L$x_libraries" +fi + +AC_HEADER_STDC +AC_CHECK_HEADERS([errno.h limits.h stddef.h stdlib.h string.h unistd.h]) + +dnl if we're configuring on a system w/out gettext, don't fall over +m4_ifndef([AM_ICONV],[m4_define([AM_ICONV],[:])]) +AM_ICONV +# if test -n "$LIBICONV" ; then +# LIBS="$LIBS $LIBICONV" +# fi + +AC_CHECK_HEADERS(iconv.h, + [AC_MSG_CHECKING(whether iconv.h defines iconv_t) + AC_EGREP_HEADER([typedef.*iconv_t],iconv.h, + [AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_ICONV_T_DEF, 1, + [Define if <iconv.h> defines iconv_t.])], + AC_MSG_RESULT(no))]) + +# Checks for typedefs, structures, and compiler characteristics. +#AC_C_CONST +#AC_TYPE_SIZE_T + +# Checks for library functions. +#AC_FUNC_ERROR_AT_LINE +#AC_FUNC_MALLOC +#AC_FUNC_REALLOC +#AC_FUNC_VPRINTF +#AC_CHECK_FUNCS([floor memset sqrt strchr strdup strtol]) + +dnl do we need to specify -lm explicitly? +AC_CHECK_FUNC(sin,,[AC_CHECK_LIB(m,sin)]) + +dnl zlib is required +AC_ARG_WITH(zlib, +[ --with-zlib=DIR where to find the zlib library]) +if test "$with_zlib" != no; then + AC_CHECK_LIB(z,deflate, + [LIBS="-lz $LIBS" + AC_DEFINE(HAVE_LIBZ, 1, [Define if you have zlib.]) + with_zlib=yes], + [AC_MSG_WARN([zlib is required - see http://www.gzip.org/zlib/]) + with_zlib=no]) +fi +AM_CONDITIONAL([HAVE_LIBZ], test "$with_zlib" = yes) + +dnl libpng is required +AC_ARG_WITH(png,dnl +[ --with-png=DIR where to find the png library]) + +case $with_png in +no) ;; +yes|"") + PKG_CHECK_MODULES([LIBPNG], libpng, [ + with_png=yes + ],[ + if test "$with_png" = yes; then + AC_MSG_ERROR([png support requested, but not found - see http://www.libpng.org/pub/png/]) + fi + with_png=no + ]) + ;; +*) + AC_MSG_CHECKING([libpng-config script]) + LIBPNG_CONFIG=$with_png/bin/libpng-config + if test -e "$LIBPNG_CONFIG"; then + LIBPNG_CFLAGS=`$LIBPNG_CONFIG --cflags` + LIBPNG_LIBS=`$LIBPNG_CONFIG --ldflags` + with_png=yes + AC_MSG_RESULT([$LIBPNG_CONFIG, cflags: $LIBPNG_CFLAGS, libs: $LIBPNG_LIBS]) + else + AC_MSG_ERROR([png support requested, but not found at requested location: $LIBPNG_CONFIG]) + fi + ;; +esac +if test "$with_png" != no; then + CPPFLAGS="$CPPFLAGS $LIBPNG_CFLAGS" + LIBS="$LIBS $LIBPNG_LIBS" + FEATURES="GD_PNG $FEATURES" + AC_DEFINE(HAVE_LIBPNG, 1, [Define if you have the png library.]) +fi +AM_CONDITIONAL([HAVE_LIBPNG], test "$with_png" = yes) + +dnl FreeType configure tests snarfed from libwmf .. +AC_ARG_WITH(freetype,dnl +[ --with-freetype=DIR where to find the freetype 2.x library]]) + +case $with_freetype in +no) ;; +yes|"") + dnl All freetype2 versions are numerically much larger than the actual + dnl version number you see in the tarball. This is because the number + dnl corresponds to the shared library version rather than the release. + dnl 9.8.3 is the version that freetype2-2.1.10 used. + PKG_CHECK_MODULES([LIBFREETYPE], [freetype2 >= 9.8.3], [ + with_freetype=yes + ],[ + if test "$with_freetype" = yes; then + AC_MSG_ERROR([freetype support requested, but not found]) + fi + with_freetype=no + ]) + ;; +*) + FREETYPE_CONFIG=$with_freetype/bin/freetype-config + if test -e "$FREETYPE_CONFIG"; then + LIBFREETYPE_CFLAGS=`$FREETYPE_CONFIG --cflags` + LIBFREETYPE_LIBS=`$FREETYPE_CONFIG --libs` + with_freetype=yes + else + AC_MSG_ERROR([freetype support requested, but not found: $FREETYPE_CONFIG]) + fi + ;; +esac +if test "$with_freetype" = yes; then + CPPFLAGS="$CPPFLAGS $LIBFREETYPE_CFLAGS" + LIBS="$LIBS $LIBFREETYPE_LIBS" + FEATURES="GD_FREETYPE $FEATURES" + AC_DEFINE(HAVE_LIBFREETYPE, 1, [Define if you have the freetype library.]) + AC_DEFINE(HAVE_FT2BUILD_H, 1, [Define if you have the ft2build.h header.]) +fi +AM_CONDITIONAL([HAVE_LIBFREETYPE], test "$with_freetype" = yes) + +dnl check for libfontconfig by default +AC_ARG_WITH(fontconfig,dnl +[ --with-fontconfig=DIR where to find the fontconfig library]) + +case $with_fontconfig in +no) ;; +yes|"") + PKG_CHECK_MODULES([LIBFONTCONFIG], fontconfig, [with_fontconfig=yes], + [ + if test "$with_fontconfig" = yes; then + AC_MSG_ERROR([fontconfig support requested, but not found]) + fi + with_fontconfig=no + ]) + ;; +*) + save_LIBS="$LIBS" + save_CPPFLAGS="$CPPFLAGS" + + if test -d "$with_fontconfig"; then + LIBFONTCONFIG_CFLAGS="-I$with_fontconfig/include" + LIBFONTCONFIG_LIBS="-L$with_fontconfig/lib" + fi + + CPPFLAGS="$CPPFLAGS $LIBFONTCONFIG_CFLAGS" + LIBS="$LIBS $LIBFONTCONFIG_LIBS" + + AC_CHECK_LIB(fontconfig, FcInit, + [ + LIBFONTCONFIG_LIBS="$LIBFONTCONFIG_LIBS -lfontconfig" + with_fontconfig=yes + ],[ + if test "$with_fontconfig" != ""; then + AC_MSG_ERROR([fontconfig support requested, but not found]) + else + with_fontconfig=no + fi + ]) + + CPPFLAGS="$save_CPPFLAGS" + LIBS="$save_LIBS" + ;; +esac + +if test "$with_fontconfig" != no; then + CPPFLAGS="$CPPFLAGS $LIBFONTCONFIG_CFLAGS" + LIBS="$LIBS $LIBFONTCONFIG_LIBS -lfontconfig" + FEATURES="GD_FONTCONFIG $FEATURES" + AC_DEFINE(HAVE_LIBFONTCONFIG, 1, [ Define if you have the fontconfig library. ]) +fi +AM_CONDITIONAL([HAVE_LIBFONTCONFIG], test "$with_fontconfig" = yes) + +dnl check for libjpeg by default +AC_ARG_WITH(jpeg,dnl +[ --with-jpeg=DIR where to find the jpeg library], + [if test -d "$withval"; then + LDFLAGS="$LDFLAGS -L$withval/lib" + CFLAGS="$CFLAGS -I$withval/include" + fi], + withval=yes) + +if test "$withval" != no; then + AC_CHECK_LIB(jpeg,jpeg_set_defaults, + [LIBS="-ljpeg $LIBS" + FEATURES="GD_JPEG $FEATURES" + AC_DEFINE(HAVE_LIBJPEG, 1, [ Define if you have the jpeg library. ])]) +else + ac_cv_lib_jpeg_jpeg_set_defaults=no +fi +AM_CONDITIONAL([HAVE_LIBJPEG], test "$ac_cv_lib_jpeg_jpeg_set_defaults" = yes) + +dnl check for libXpm by default +AC_ARG_WITH(xpm,dnl +[ --with-xpm=DIR where to find the xpm library]) + +case $with_xpm in +no) ;; +yes|"") + PKG_CHECK_MODULES([LIBXPM], xpm, [with_xpm=yes], + [ + if test "$with_xpm" = yes; then + AC_MSG_ERROR([Xpm support requested, but not found]) + fi + with_xpm=no + ]) + ;; +*) + save_LIBS="$LIBS" + save_CPPFLAGS="$CPPFLAGS" + + if test -d "$with_xpm"; then + LIBXPM_CFLAGS="-I$with_xpm/include" + LIBXPM_LIBS="-L$with_xpm/lib -lXpm" + fi + + CPPFLAGS="$CPPFLAGS $LIBXPM_CFLAGS" + LIBS="$LIBS $LIBXPM_LIBS" + + AC_CHECK_LIB(Xpm,XpmReadFileToXpmImage, + [ + if test -z "$LIBXPM_LIBS"; then + LIBXPM_LIBS="-lXpm" + fi + with_xpm=yes + ],[ + if test "$with_xpm" != ""; then + AC_MSG_ERROR([Xpm support requested, but not found]) + else + with_xpm=no + fi + ]) + + CPPFLAGS="$save_CPPFLAGS" + LIBS="$save_LIBS" + ;; +esac + +if test "$with_xpm" != no; then + CPPFLAGS="$CPPFLAGS $LIBXPM_CFLAGS" + LIBS="$LIBS $LIBXPM_LIBS" + FEATURES="GD_XPM $FEATURES" + AC_DEFINE(HAVE_LIBXPM, 1, [ Define if you have the Xpm library. ]) +fi +AM_CONDITIONAL([HAVE_LIBXPM], test "$with_xpm" = yes) + +dnl check for libvpx by default +AC_ARG_WITH(vpx,dnl +[ --with-vpx=DIR where to find the vpx library]) + +case $with_vpx in +no) ;; +yes|"") + PKG_CHECK_MODULES([LIBVPX], vpx, [with_vpx=yes], + [ + PKG_CHECK_MODULES([LIBVPX], libvpx, [with_vpx=yes], + [ + if test "$with_vpx" = yes; then + AC_MSG_ERROR([VPX support requested, but not found]) + fi + with_vpx=no + ]) + ]) + ;; +*) + save_LIBS="$LIBS" + save_CPPFLAGS="$CPPFLAGS" + + if test -d "$with_vpx"; then + LIBVPX_CFLAGS="-I$with_vpx/include" + LIBVPX_LIBS="-L$with_vpx/lib -lvpx" + fi + + CPPFLAGS="$CPPFLAGS $LIBVPX_CFLAGS" + LIBS="$LIBS $LIBVPX_LIBS" + + AC_CHECK_LIB(vpx,vpx_codec_destroy, + [ + if test -z "$LIBVPX_LIBS"; then + LIBVPX_LIBS="-lvpx" + fi + with_vpx=yes + ],[ + if test "$with_vpx" != ""; then + AC_MSG_ERROR([vpx support requested, but not found]) + else + with_vpx=no + fi + ]) + + CPPFLAGS="$save_CPPFLAGS" + LIBS="$save_LIBS" + ;; +esac + +if test "$with_vpx" != no; then + CPPFLAGS="$CPPFLAGS $LIBVPX_CFLAGS" + LIBS="$LIBS $LIBVPX_LIBS" + FEATURES="GD_VPX $FEATURES" + AC_DEFINE(HAVE_LIBVPX, 1, [ Define if you have the VPX library. ]) +fi +AM_CONDITIONAL([HAVE_LIBVPX], test "$with_vpx" = yes) + +dnl check for libtiff by default +AC_ARG_WITH(tiff,dnl +[ --with-tiff=DIR where to find the TIFF library]) + +case $with_tiff in +no) ;; +yes|"") + PKG_CHECK_MODULES([LIBTIFF], libtiff-4, [with_tiff=yes], + [ + if test "$with_tiff" = yes; then + AC_MSG_ERROR([TIFF support requested, but not found]) + fi + with_tiff=no + ]) + ;; +*) + save_CPPFLAGS="$CPPFLAGS" + save_LIBS="$LIBS" + + if test -d "$with_tiff"; then + LIBTIFF_CFLAGS="-I$with_tiff/include" + LIBTIFF_LIBS="-L$with_tiff/lib" + fi + + CPPFLAGS="$CPPFLAGS $LIBTIFF_CFLAGS" + LIBS="$LIBS $LIBTIFF_LIBS" + + AC_CHECK_LIB(tiff,TIFFClientOpen, + [ + LIBTIFF_LIBS="$LIBTIFF_LIBS -ltiff" + with_tiff=yes + ],[ + if test "$with_tiff" != ""; then + AC_MSG_ERROR([tiff support requested, but not found]) + else + with_tiff=no + fi + ]) + + CPPFLAGS="$save_CPPFLAGS" + LIBS="$save_LIBS" + ;; +esac + +if test "$with_tiff" != no; then + CPPFLAGS="$CPPFLAGS $LIBTIFF_CFLAGS" + LIBS="$LIBS $LIBTIFF_LIBS" + FEATURES="GD_TIFF $FEATURES" + AC_DEFINE(HAVE_LIBTIFF, 1, [ Define if you have the Tiff library. ]) +fi +AM_CONDITIONAL([HAVE_LIBTIFF], test "$with_tiff" = yes) + +gl_VISIBILITY() +CFLAGS="$CFLAGS $CFLAG_VISIBILITY" + +AX_PTHREAD() + +MINGW_AC_WIN32_NATIVE_HOST() + +if test "$mingw_cv_win32_host" = yes; then +AC_DEFINE([BGDWIN32], [], [Define is you are building for Win32 API]) +fi + +dnl report configuration +AC_MSG_RESULT([ +** Configuration summary for $PACKAGE $VERSION: + + Support for Zlib: $with_zlib + Support for PNG library: $with_png + Support for JPEG library: $ac_cv_lib_jpeg_jpeg_set_defaults + Support for VPX library: $with_vpx + Support for TIFF library: $with_tiff + Support for Freetype 2.x library: $with_freetype + Support for Fontconfig library: $with_fontconfig + Support for Xpm library: $with_xpm + Support for pthreads: $ax_pthread_ok +]) + +AC_CONFIG_FILES([Makefile + src/Makefile + tests/Makefile + tests/test_config.h + config/Makefile + config/gdlib-config + config/gdlib.pc]) + +AC_OUTPUT diff --git a/Build/source/libs/gd/libgd-2.1.1/docs/INSTALL b/Build/source/libs/gd/libgd-2.1.1/docs/INSTALL new file mode 100644 index 00000000000..a1e89e18ad2 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/docs/INSTALL @@ -0,0 +1,370 @@ +Installation Instructions +************************* + +Copyright (C) 1994-1996, 1999-2002, 2004-2011 Free Software Foundation, +Inc. + + Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. This file is offered as-is, +without warranty of any kind. + +Basic Installation +================== + + Briefly, the shell commands `./configure; make; make install' should +configure, build, and install this package. The following +more-detailed instructions are generic; see the `README' file for +instructions specific to this package. Some packages provide this +`INSTALL' file but do not implement all of the features documented +below. The lack of an optional feature in a given package is not +necessarily a bug. More recommendations for GNU packages can be found +in *note Makefile Conventions: (standards)Makefile Conventions. + + The `configure' shell script attempts to guess correct values for +various system-dependent variables used during compilation. It uses +those values to create a `Makefile' in each directory of the package. +It may also create one or more `.h' files containing system-dependent +definitions. Finally, it creates a shell script `config.status' that +you can run in the future to recreate the current configuration, and a +file `config.log' containing compiler output (useful mainly for +debugging `configure'). + + It can also use an optional file (typically called `config.cache' +and enabled with `--cache-file=config.cache' or simply `-C') that saves +the results of its tests to speed up reconfiguring. Caching is +disabled by default to prevent problems with accidental use of stale +cache files. + + If you need to do unusual things to compile the package, please try +to figure out how `configure' could check whether to do them, and mail +diffs or instructions to the address given in the `README' so they can +be considered for the next release. If you are using the cache, and at +some point `config.cache' contains results you don't want to keep, you +may remove or edit it. + + The file `configure.ac' (or `configure.in') is used to create +`configure' by a program called `autoconf'. You need `configure.ac' if +you want to change it or regenerate `configure' using a newer version +of `autoconf'. + + The simplest way to compile this package is: + + 1. `cd' to the directory containing the package's source code and type + `./configure' to configure the package for your system. + + Running `configure' might take a while. While running, it prints + some messages telling which features it is checking for. + + 2. Type `make' to compile the package. + + 3. Optionally, type `make check' to run any self-tests that come with + the package, generally using the just-built uninstalled binaries. + + 4. Type `make install' to install the programs and any data files and + documentation. When installing into a prefix owned by root, it is + recommended that the package be configured and built as a regular + user, and only the `make install' phase executed with root + privileges. + + 5. Optionally, type `make installcheck' to repeat any self-tests, but + this time using the binaries in their final installed location. + This target does not install anything. Running this target as a + regular user, particularly if the prior `make install' required + root privileges, verifies that the installation completed + correctly. + + 6. You can remove the program binaries and object files from the + source code directory by typing `make clean'. To also remove the + files that `configure' created (so you can compile the package for + a different kind of computer), type `make distclean'. There is + also a `make maintainer-clean' target, but that is intended mainly + for the package's developers. If you use it, you may have to get + all sorts of other programs in order to regenerate files that came + with the distribution. + + 7. Often, you can also type `make uninstall' to remove the installed + files again. In practice, not all packages have tested that + uninstallation works correctly, even though it is required by the + GNU Coding Standards. + + 8. Some packages, particularly those that use Automake, provide `make + distcheck', which can by used by developers to test that all other + targets like `make install' and `make uninstall' work correctly. + This target is generally not run by end users. + +Compilers and Options +===================== + + Some systems require unusual options for compilation or linking that +the `configure' script does not know about. Run `./configure --help' +for details on some of the pertinent environment variables. + + You can give `configure' initial values for configuration parameters +by setting variables in the command line or in the environment. Here +is an example: + + ./configure CC=c99 CFLAGS=-g LIBS=-lposix + + *Note Defining Variables::, for more details. + +Compiling For Multiple Architectures +==================================== + + You can compile the package for more than one kind of computer at the +same time, by placing the object files for each architecture in their +own directory. To do this, you can use GNU `make'. `cd' to the +directory where you want the object files and executables to go and run +the `configure' script. `configure' automatically checks for the +source code in the directory that `configure' is in and in `..'. This +is known as a "VPATH" build. + + With a non-GNU `make', it is safer to compile the package for one +architecture at a time in the source code directory. After you have +installed the package for one architecture, use `make distclean' before +reconfiguring for another architecture. + + On MacOS X 10.5 and later systems, you can create libraries and +executables that work on multiple system types--known as "fat" or +"universal" binaries--by specifying multiple `-arch' options to the +compiler but only a single `-arch' option to the preprocessor. Like +this: + + ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ + CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ + CPP="gcc -E" CXXCPP="g++ -E" + + This is not guaranteed to produce working output in all cases, you +may have to build one architecture at a time and combine the results +using the `lipo' tool if you have problems. + +Installation Names +================== + + By default, `make install' installs the package's commands under +`/usr/local/bin', include files under `/usr/local/include', etc. You +can specify an installation prefix other than `/usr/local' by giving +`configure' the option `--prefix=PREFIX', where PREFIX must be an +absolute file name. + + You can specify separate installation prefixes for +architecture-specific files and architecture-independent files. If you +pass the option `--exec-prefix=PREFIX' to `configure', the package uses +PREFIX as the prefix for installing programs and libraries. +Documentation and other data files still use the regular prefix. + + In addition, if you use an unusual directory layout you can give +options like `--bindir=DIR' to specify different values for particular +kinds of files. Run `configure --help' for a list of the directories +you can set and what kinds of files go in them. In general, the +default for these options is expressed in terms of `${prefix}', so that +specifying just `--prefix' will affect all of the other directory +specifications that were not explicitly provided. + + The most portable way to affect installation locations is to pass the +correct locations to `configure'; however, many packages provide one or +both of the following shortcuts of passing variable assignments to the +`make install' command line to change installation locations without +having to reconfigure or recompile. + + The first method involves providing an override variable for each +affected directory. For example, `make install +prefix=/alternate/directory' will choose an alternate location for all +directory configuration variables that were expressed in terms of +`${prefix}'. Any directories that were specified during `configure', +but not in terms of `${prefix}', must each be overridden at install +time for the entire installation to be relocated. The approach of +makefile variable overrides for each directory variable is required by +the GNU Coding Standards, and ideally causes no recompilation. +However, some platforms have known limitations with the semantics of +shared libraries that end up requiring recompilation when using this +method, particularly noticeable in packages that use GNU Libtool. + + The second method involves providing the `DESTDIR' variable. For +example, `make install DESTDIR=/alternate/directory' will prepend +`/alternate/directory' before all installation names. The approach of +`DESTDIR' overrides is not required by the GNU Coding Standards, and +does not work on platforms that have drive letters. On the other hand, +it does better at avoiding recompilation issues, and works well even +when some directory options were not specified in terms of `${prefix}' +at `configure' time. + +Optional Features +================= + + If the package supports it, you can cause programs to be installed +with an extra prefix or suffix on their names by giving `configure' the +option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'. + + Some packages pay attention to `--enable-FEATURE' options to +`configure', where FEATURE indicates an optional part of the package. +They may also pay attention to `--with-PACKAGE' options, where PACKAGE +is something like `gnu-as' or `x' (for the X Window System). The +`README' should mention any `--enable-' and `--with-' options that the +package recognizes. + + For packages that use the X Window System, `configure' can usually +find the X include and library files automatically, but if it doesn't, +you can use the `configure' options `--x-includes=DIR' and +`--x-libraries=DIR' to specify their locations. + + Some packages offer the ability to configure how verbose the +execution of `make' will be. For these packages, running `./configure +--enable-silent-rules' sets the default to minimal output, which can be +overridden with `make V=1'; while running `./configure +--disable-silent-rules' sets the default to verbose, which can be +overridden with `make V=0'. + +Particular systems +================== + + On HP-UX, the default C compiler is not ANSI C compatible. If GNU +CC is not installed, it is recommended to use the following options in +order to use an ANSI C compiler: + + ./configure CC="cc -Ae -D_XOPEN_SOURCE=500" + +and if that doesn't work, install pre-built binaries of GCC for HP-UX. + + HP-UX `make' updates targets which have the same time stamps as +their prerequisites, which makes it generally unusable when shipped +generated files such as `configure' are involved. Use GNU `make' +instead. + + On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot +parse its `<wchar.h>' header file. The option `-nodtk' can be used as +a workaround. If GNU CC is not installed, it is therefore recommended +to try + + ./configure CC="cc" + +and if that doesn't work, try + + ./configure CC="cc -nodtk" + + On Solaris, don't put `/usr/ucb' early in your `PATH'. This +directory contains several dysfunctional programs; working variants of +these programs are available in `/usr/bin'. So, if you need `/usr/ucb' +in your `PATH', put it _after_ `/usr/bin'. + + On Haiku, software installed for all users goes in `/boot/common', +not `/usr/local'. It is recommended to use the following options: + + ./configure --prefix=/boot/common + +Specifying the System Type +========================== + + There may be some features `configure' cannot figure out +automatically, but needs to determine by the type of machine the package +will run on. Usually, assuming the package is built to be run on the +_same_ architectures, `configure' can figure that out, but if it prints +a message saying it cannot guess the machine type, give it the +`--build=TYPE' option. TYPE can either be a short name for the system +type, such as `sun4', or a canonical name which has the form: + + CPU-COMPANY-SYSTEM + +where SYSTEM can have one of these forms: + + OS + KERNEL-OS + + See the file `config.sub' for the possible values of each field. If +`config.sub' isn't included in this package, then this package doesn't +need to know the machine type. + + If you are _building_ compiler tools for cross-compiling, you should +use the option `--target=TYPE' to select the type of system they will +produce code for. + + If you want to _use_ a cross compiler, that generates code for a +platform different from the build platform, you should specify the +"host" platform (i.e., that on which the generated programs will +eventually be run) with `--host=TYPE'. + +Sharing Defaults +================ + + If you want to set default values for `configure' scripts to share, +you can create a site shell script called `config.site' that gives +default values for variables like `CC', `cache_file', and `prefix'. +`configure' looks for `PREFIX/share/config.site' if it exists, then +`PREFIX/etc/config.site' if it exists. Or, you can set the +`CONFIG_SITE' environment variable to the location of the site script. +A warning: not all `configure' scripts look for a site script. + +Defining Variables +================== + + Variables not defined in a site shell script can be set in the +environment passed to `configure'. However, some packages may run +configure again during the build, and the customized values of these +variables may be lost. In order to avoid this problem, you should set +them in the `configure' command line, using `VAR=value'. For example: + + ./configure CC=/usr/local2/bin/gcc + +causes the specified `gcc' to be used as the C compiler (unless it is +overridden in the site shell script). + +Unfortunately, this technique does not work for `CONFIG_SHELL' due to +an Autoconf bug. Until the bug is fixed you can use this workaround: + + CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash + +`configure' Invocation +====================== + + `configure' recognizes the following options to control how it +operates. + +`--help' +`-h' + Print a summary of all of the options to `configure', and exit. + +`--help=short' +`--help=recursive' + Print a summary of the options unique to this package's + `configure', and exit. The `short' variant lists options used + only in the top level, while the `recursive' variant lists options + also present in any nested packages. + +`--version' +`-V' + Print the version of Autoconf used to generate the `configure' + script, and exit. + +`--cache-file=FILE' + Enable the cache: use and save the results of the tests in FILE, + traditionally `config.cache'. FILE defaults to `/dev/null' to + disable caching. + +`--config-cache' +`-C' + Alias for `--cache-file=config.cache'. + +`--quiet' +`--silent' +`-q' + Do not print messages saying which checks are being made. To + suppress all normal output, redirect it to `/dev/null' (any error + messages will still be shown). + +`--srcdir=DIR' + Look for the package's source code in directory DIR. Usually + `configure' can determine that directory automatically. + +`--prefix=DIR' + Use DIR as the installation prefix. *note Installation Names:: + for more details, including other options available for fine-tuning + the installation locations. + +`--no-create' +`-n' + Run the configure checks, but stop before creating any output + files. + +`configure' also accepts some other, not widely useful, options. Run +`configure --help' for more details. + diff --git a/Build/source/libs/gd/libgd-2.1.1/docs/INSTALL.Solaris b/Build/source/libs/gd/libgd-2.1.1/docs/INSTALL.Solaris new file mode 100644 index 00000000000..d6b5bd1adac --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/docs/INSTALL.Solaris @@ -0,0 +1,16 @@ +Solaris CAVEATS +=============== + +If you are using GNU iconv library installed in f.e. /opt, you will +need to add the header location to CMAKE= in configure invokation to +ensure that the system iconv.h header is not used when searching for +iconv library. + +The resulting ./configure invokation would look something like this: + +MAKE=gmake CC="gcc -m64" ./configure --prefix=/opt/local \ +CFLAGS="-I/opt/local/include -DHAVE_ICONV -O2 -fomit-frame-pointer -pipe -m64" \ +--with-png=/usr --with-freetype=/opt/local + +For more information and discussion see: +https://bitbucket.org/libgd/gd-libgd/issue/76 diff --git a/Build/source/libs/gd/libgd-2.1.1/docs/README.CMAKE b/Build/source/libs/gd/libgd-2.1.1/docs/README.CMAKE new file mode 100644 index 00000000000..baf583c3ba6 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/docs/README.CMAKE @@ -0,0 +1,39 @@ +||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| +$Id$ +Tobuild GD using CMake, all you need is (add the cmake options if you need any +or if the default libs and include paths are not the default) : + +In a sub directory: +$ mkdir bld +$ cd bld +$ cmake -DBUILD_TEST=1 <options> + +The available options are: +ENABLE_PNG=1 +ENABLE_JPEG=1 +ENABLE_TIFF=1 +ENABLE_FREETYPE=1 +ENABLE_FONTCONFIG=1 +ENABLE_XPM=1 + +You can optionnally run our tests suite using: +$ ctest . + +Or if you like to build in the source tree: +$ cmake -DBUILD_TEST=1 . +$ ctest . + +Add "-DCMAKE_BUILD_TYPE=DEBUG" if you like to have a debug version. + + +Typical usage with only PNG enabled: + +This command generates VS7 project files and add some custom libraries and includes directories (libpng in this case): + +cmake -DCMAKE_GENERATOR="Visual Studio 7 .NET 2003" -DENABLE_PNG=1 -DCMAKE_LIBRARY_PATH=c:\gd_build\gd_deps\lib -DCMAKE_INCLUDE_PATH=c:\gd_build\gd_deps\include c:\libgd_src + +A typical CMake call to build using the MinGW tools: + +cmake -G"MinGW Makefiles" -DCMAKE_LIBRARY_PATH=c:\mingw\lib -DCMAKE_INCLUDE_PATH=c:\MinGW\include -DENABLE_JPEG=On -DBUILD_TEST=On -DCMAKE_RELEASE_TYPE=DEBUG ..\libgd_head + +Given that your MinGW install is under c:\mingw and that you install all libraries using the /usr prefix diff --git a/Build/source/libs/gd/libgd-2.1.1/docs/README.JPN b/Build/source/libs/gd/libgd-2.1.1/docs/README.JPN new file mode 100644 index 00000000000..65db00b5534 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/docs/README.JPN @@ -0,0 +1,39 @@ + gd $B%i%$%V%i%j$GF|K\8lJ8;zNs$r;H$&>e$G$NCm0U;v9`(B + + $B;32l@5?M(B (ma@yama-ga.com) + + +gd-1.7.0 $B$+$i$O$=$N$^$^$G(B gdImageStringTTF() $B$KBP$7$F(B +SJIS encoding $B$N%U%)%s%H$,;HMQ$G$-$^$9!#(B + + $B"((B Unicode encoding $B$N%U%)%s%H$KBP$7$F$OF|K\8lJ8;zNs$r(B UTF-8 $B$G(B + $B;XDj$9$l$PF|K\8l$,I=<($G$-$^$9!#(B + +$B$D$^$j(B gdImageStringTTF() $B$G(B SJIS encoding $B$N%U%)%s%H$r;XDj$9$k$H(B +$BJ8;zNs$OL5>r7o$KF|K\8l$G$"$k$H2r<a$5$l!"4A;z%3!<%I(B (EUC, SJIS, 7bit JIS) +$B$,<+F0H=JL$5$l$FE,@Z$K=hM}$5$l$^$9!#(B + +$B99$K(B UNICODE encoding $B$N%U%)%s%H$KBP$7$F$b(B JIS $B7O$NF|K\8l(B (EUC, SJIS, 7bit JIS) +$B$r;HMQ$9$k>l9g$O!"%3%s%Q%$%k;~$K(B -DJISX0208 $B$rIU$1$F%3%s%Q%$%k$7$F$/$@$5$$!#(B +$B$3$&$9$k$H(B gdImageStringTTF() $B$G;XDj$5$l$?J8;zNs$K(B ASCII $B0J30$NJ8;z$,$"$k$H(B +$BL5>r7o$KF|K\8lJ8;zNs$G$"$k$H2r<a$5$l!"4A;z%3!<%I$r<+F0H=JL8e$K(B +$BE,@Z$K=hM}$5$l$^$9!#(B + +$B$?$@$7$3$N>l9g$O(B UTF-8 $B$NF|K\8lJ8;zNs$r07$($J$/$J$j$^$9$N$G!"(B +$B$4MxMQ$N4D6-Ey$K1~$8$F(B -DJISX0208 $B$rIU$1$k$+H]$+$r7h$a$F$/$@$5$$!#(B + +$B4A;z%3!<%I$NJQ49$K(B OS $BIUB0$N(B iconv() $B$r;H$&>l9g$O(B +CFLAGS $B$K(B -DHAVE_ICONV $B$rIU$1$F%3%s%Q%$%k$7$F$/$@$5$$!#(B +$B$3$N>l9g$K(B -DHAVE_STDARG_H $B$H(B -DHAVE_ERRNO_H $B$bIU$1$F$*$/$H(B +$B4A;z%3!<%IJQ49$N:]$K%(%i!<$,H/@8$7$?>l9g$KE,@Z$J%a%C%;!<%8$r(B +$BI=<($9$k$h$&$K$J$j$^$9!#(B + + +$B!y(B EUC $B$+(B SJIS $B$+H=JL$G$-$J$+$C$?>l9g$N4A;z%3!<%I$NH=JLJ}K!(B + + (1) $B4D6-JQ?t(B LC_ALL, LC_CTYPE, LANG $B$r$3$N=gHV$G%A%'%C%/$9$k(B + (2) $B4D6-JQ?t$+$i$bH=JL$G$-$J$+$C$?>l9g$O(B UNIX $B$J$i$P(B EUC$B!"(B + Win32 $B$J$i$P(B SJIS $B$H8+$J$9(B + +$B%3%s%Q%$%k;~$K(B -DSJISPRE $B$rIU$1$F%3%s%Q%$%k$9$l$P!"(BUNIX $B$G$"$C$F$b(B +SJIS $B$rM%@h$9$k$h$&$K$J$j$^$9!#(B diff --git a/Build/source/libs/gd/libgd-2.1.1/docs/README.TESTING b/Build/source/libs/gd/libgd-2.1.1/docs/README.TESTING new file mode 100644 index 00000000000..a4c50efe3e6 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/docs/README.TESTING @@ -0,0 +1,62 @@ +||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| + +To run the tests suite, all you need is (add the cmake options if you need any +or if the default libs and include paths are not the default) : + +In a sub directory: +$ mkdir bld +$ cd bld +$ cmake -DBUILD_TEST=1 .. +$ ctest . + +Or if you like to build in the source tree: +$ cmake -DBUILD_TEST=1 . +$ ctest . + +Add "-DCMAKE_BUILD_TYPE=DEBUG" if you like to have a debug version. + +If you like to run the tests against a installed GD library, set the following +environment variables: + +export CMAKE_INCLUDE_PATH=/path/to/the/gd/include +export CMAKE_LIBRARY_PATH=/path/to/the/gd/lib + +then call cmake using: + +$ cmake -DUSE_EXT_GD=1 -DBUILD_TEST=1 +$ make +and finally: + +$ ctest . + +I will certainly add a nice CMake option to give prefix later. + +What to do if tests fail on your platform and you use the last GD release? +either from your favourite distributions or from http://www.libgd.org or git? + +If you use a packaged version of the GD Library (installed from RPM, deb or +ports, gentoo packages or any other packages format or distribution), please try +to run the tests using the source releases available at: + +http://www.libgd.org/Downloads + +If the tests fail using our source release, please report a bug here: + +http://bugs.libgd.org + +You can attach the two files available in: + +./Testing/Temporary + +Later versions will have an automatic post mode. + +If the tests run successfully, please report a bug to the maintainer of the +packages (debian, bsd, ubuntu or whoever is responsible for the packages). + +Reasons of failures: +Exception: SegFault: self explaining +Failed test failed, check the log to know where +timeout the default timeout is 5 seconds. Some test may + have infinite loops when compiled against old versions + of the GD library (esp. 2.0.33 or earlier) + diff --git a/Build/source/libs/gd/libgd-2.1.1/docs/README.TXT b/Build/source/libs/gd/libgd-2.1.1/docs/README.TXT new file mode 100644 index 00000000000..39725dd62c1 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/docs/README.TXT @@ -0,0 +1,61 @@ +For documentation, browse index.html. + +Quick install guide: + +If the sources have been fetched from git, run bootstrap.sh [options]. + +From a released source, use: +1. Type './configure' +2. Type 'make install' + +Generic configuration instructions are in the file INSTALL. + +The following 3rd-party libraries will be used by gd if found by configure. +While gd will compile and install even without these, we suggest that at +least zlib and libpng are installed, and recommend that freetype and jpeg +are installed as well: + +1. zlib, available from http://www.gzip.org/zlib/ + Data compression library + +2. libpng, available from http://www.libpng.org/pub/png/ + Portable Network Graphics library; requires zlib + +3. FreeType 2.x, available from http://www.freetype.org/ + Free, high-quality, and portable font engine + +4. JPEG library, available from http://www.ijg.org/ + Portable JPEG compression/decompression library + +5. XPM, available from http://koala.ilog.fr/lehors/xpm.html + X Pixmap library + +If any of these libraries are installed, but not detected by configure, +you can use the following command line options: + +--with-png=DIR + + Without the DIR argument, configure will check for png header files and + libraries in a default location. To switch off png support, use + --without-png, or --with-png=no. + + If the DIR argument is specified, configure tries to find the png header + files in DIR/include, and the libraries in DIR/lib. To accommodate + OpenBSD ports, DIR/include/libpng is also checked if necessary. + +--with-freetype=DIR + + Dto. for freetype 2.x library. The search path for include files is + DIR/include/freetype2. + +--with-jpeg=DIR + + Dto. for jpeg library. + +--with-xpm=DIR + + Dto. for xpm library. + + --with-tiff=DIR + +Dto. for TIFF library. diff --git a/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/license.txt b/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/license.txt new file mode 100644 index 00000000000..4164bce4bc7 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/license.txt @@ -0,0 +1,74 @@ +Title: License + +Credits and license terms: + +> In order to resolve any possible confusion regarding the authorship of +> gd, the following copyright statement covers all of the authors who +> have required such a statement. If you are aware of any oversights in +> this copyright notice, please contact Pierre-A. Joye who will be +> pleased to correct them. +> +> Portions copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, +> 2002, 2003, 2004 by Cold Spring Harbor Laboratory. Funded under +> Grant P41-RR02188 by the National Institutes of Health. +> +> Portions copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, +> 2004 by Boutell.Com, Inc. +> +> Portions relating to GD2 format copyright 1999, 2000, 2001, 2002, +> 2003, 2004 Philip Warner. +> +> Portions relating to PNG copyright 1999, 2000, 2001, 2002, 2003, +> 2004 Greg Roelofs. +> +> Portions relating to gdttf.c copyright 1999, 2000, 2001, 2002, +> 2003, 2004 John Ellson (ellson@graphviz.org). +> +> Portions relating to gdft.c copyright 2001, 2002, 2003, 2004 John +> Ellson (ellson@graphviz.org). +> +> Portions copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 +> Pierre-Alain Joye (pierre@libgd.org). +> +> Portions relating to JPEG and to color quantization copyright +> 2000, 2001, 2002, 2003, 2004, Doug Becker and copyright (C) 1994, +> 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Thomas +> G. Lane. This software is based in part on the work of the +> Independent JPEG Group. See the file README-JPEG.TXT for more +> information. +> +> Portions relating to GIF compression copyright 1989 by Jef +> Poskanzer and David Rowley, with modifications for thread safety +> by Thomas Boutell. +> +> Portions relating to GIF decompression copyright 1990, 1991, 1993 +> by David Koblas, with modifications for thread safety by Thomas +> Boutell. +> +> Portions relating to WBMP copyright 2000, 2001, 2002, 2003, 2004 +> Maurice Szmurlo and Johan Van den Brande. +> +> Portions relating to GIF animations copyright 2004 Jaakko Hyvätti +> (jaakko.hyvatti@iki.fi) +> +> Permission has been granted to copy, distribute and modify gd in +> any context without fee, including a commercial application, +> provided that this notice is present in user-accessible supporting +> documentation. +> +> This does not affect your ownership of the derived work itself, +> and the intent is to assure proper credit for the authors of gd, +> not to interfere with your productive use of gd. If you have +> questions, ask. "Derived works" includes all programs that utilize +> the library. Credit must be given in user-accessible +> documentation. +> +> This software is provided "AS IS." The copyright holders disclaim +> all warranties, either express or implied, including but not +> limited to implied warranties of merchantability and fitness for a +> particular purpose, with respect to this code and accompanying +> documentation. +> +> Although their code does not appear in the current release, the +> authors also wish to thank Hutchison Avenue Software Corporation +> for their prior contributions. diff --git a/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/nobgd.pl b/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/nobgd.pl new file mode 100644 index 00000000000..e1c34624a81 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/nobgd.pl @@ -0,0 +1,58 @@ +#!/usr/bin/env perl + +# Copy C source files (i.e. *.[ch]) from $src to $dest, first +# stripping out uses of the macro BGD_DECLARE(<type>). A line must +# begin with 'BGD_DECLARE' for it to be considered a use. + +use strict; +use warnings; + +use File::Basename; + +my ($src, $dest) = @ARGV; + +die "Invalid arguments: nobgd.pl <src-dir> <dest-dir>\n" + unless ($src && $dest && -d $src && -d $dest); + +for my $file (glob("$src/*.c"), glob("$src/*.h")) { + do {local $| = 1; print "."}; + fixup($file, $dest); +} +print "\n"; + +sub fixup { + my ($src, $destDir) = @_; + my $dest = $destDir . "/" . basename($src); + + my $content = slurp($src); + $content =~ s{^ BGD_DECLARE \( ([^)]+) \)}{$1}gmx; + unslurp($dest, $content); +} + + +sub slurp { + my ($filename) = @_; + local $/; # no file separator + my $data; + + open my $fh, "<", $filename + or die "Unable to read file '$filename'.\n"; + $data = <$fh>; + close($fh); + + return $data; +} + + +sub unslurp { + my ($filename, $data) = @_; + + die "Refusing to overwrite file '$filename'\n" if -f $filename; + + open my $fh, ">", $filename + or die "Unable to open '$filename' for writing.\n"; + print {$fh} $data + or die "Error writing file '$filename'\n"; + close ($fh); +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/preamble.txt b/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/preamble.txt new file mode 100644 index 00000000000..ca2e43f9db1 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/preamble.txt @@ -0,0 +1,95 @@ +Title: About LibGD @VERSION@ + +What is gd?: + +gd is a graphics library. It allows your code to quickly draw images +complete with lines, arcs, text, multiple colors, cut and paste from +other images, and flood fills, and write out the result as a PNG or +JPEG file. This is particularly useful in World Wide Web applications, +where PNG and JPEG are two of the formats accepted for inline images +by most browsers. + +gd is not a paint program. If you are looking for a paint program, you +are looking in the wrong place. If you are not a programmer, you are +looking in the wrong place, unless you are installing a required +library in order to run an application. + +gd does not provide for every possible desirable graphics +operation. It is not necessary or desirable for gd to become a +kitchen-sink graphics package, but version 2.0 does include most +frequently requested features, including both truecolor and palette +images, resampling (smooth resizing of truecolor images) and so forth. + +gd basics: using gd in your program: + +gd lets you create PNG or JPEG images on the fly. To use gd in your +program, include the file gd.h, and link with the gd library and the +other required libraries; the syntax for most Unix flavors is: + +> -lgd -lpng -lz -ljpeg -lfreetype -lm + +Assuming that all of these libraries are available. + +If you want to use the provided simple fonts, include gdfontt.h, +gdfonts.h, gdfontmb.h, gdfontl.h and/or gdfontg.h. For more impressive +results, install FreeType 2.x and use the gdImageStringFT function. If +you are not using the provided Makefile and/or a library-based +approach, be sure to include the source modules as well in your +project. + +Here is a short example program. (For a more advanced example, see +gddemo.c, included in the distribution. gddemo.c is NOT the same +program; it demonstrates additional features!) + +>/* Bring in gd library functions */ +>#include "gd.h" +> +>/* Bring in standard I/O so we can output the PNG to a file */ +>#include <stdio.h> +> +>int main() { +> /* Declare the image */ +> gdImagePtr im; +> /* Declare output files */ +> FILE *pngout, *jpegout; +> /* Declare color indexes */ +> int black; +> int white; +> +> /* Allocate the image: 64 pixels across by 64 pixels tall */ +> im = gdImageCreate(64, 64); +> +> /* Allocate the color black (red, green and blue all minimum). +> Since this is the first color in a new image, it will +> be the background color. */ +> black = gdImageColorAllocate(im, 0, 0, 0); +> +> /* Allocate the color white (red, green and blue all maximum). */ +> white = gdImageColorAllocate(im, 255, 255, 255); +> +> /* Draw a line from the upper left to the lower right, +> using white color index. */ +> gdImageLine(im, 0, 0, 63, 63, white); +> +> /* Open a file for writing. "wb" means "write binary", important +> under MSDOS, harmless under Unix. */ +> pngout = fopen("test.png", "wb"); +> +> /* Do the same for a JPEG-format file. */ +> jpegout = fopen("test.jpg", "wb"); +> +> /* Output the image to the disk file in PNG format. */ +> gdImagePng(im, pngout); +> +> /* Output the same image in JPEG format, using the default +> JPEG quality setting. */ +> gdImageJpeg(im, jpegout, -1); +> +> /* Close the files. */ +> fclose(pngout); +> fclose(jpegout); +> +> /* Destroy the image in memory. */ +> gdImageDestroy(im); +>} +> diff --git a/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/project/Languages.txt b/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/project/Languages.txt new file mode 100644 index 00000000000..85d5fde477b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/project/Languages.txt @@ -0,0 +1,113 @@ +Format: 1.51 + +# This is the Natural Docs languages file for this project. If you change +# anything here, it will apply to THIS PROJECT ONLY. If you'd like to change +# something for all your projects, edit the Languages.txt in Natural Docs' +# Config directory instead. + + +# You can prevent certain file extensions from being scanned like this: +# Ignore Extensions: [extension] [extension] ... + + +#------------------------------------------------------------------------------- +# SYNTAX: +# +# Unlike other Natural Docs configuration files, in this file all comments +# MUST be alone on a line. Some languages deal with the # character, so you +# cannot put comments on the same line as content. +# +# Also, all lists are separated with spaces, not commas, again because some +# languages may need to use them. +# +# Language: [name] +# Alter Language: [name] +# Defines a new language or alters an existing one. Its name can use any +# characters. If any of the properties below have an add/replace form, you +# must use that when using Alter Language. +# +# The language Shebang Script is special. It's entry is only used for +# extensions, and files with those extensions have their shebang (#!) lines +# read to determine the real language of the file. Extensionless files are +# always treated this way. +# +# The language Text File is also special. It's treated as one big comment +# so you can put Natural Docs content in them without special symbols. Also, +# if you don't specify a package separator, ignored prefixes, or enum value +# behavior, it will copy those settings from the language that is used most +# in the source tree. +# +# Extensions: [extension] [extension] ... +# [Add/Replace] Extensions: [extension] [extension] ... +# Defines the file extensions of the language's source files. You can +# redefine extensions found in the main languages file. You can use * to +# mean any undefined extension. +# +# Shebang Strings: [string] [string] ... +# [Add/Replace] Shebang Strings: [string] [string] ... +# Defines a list of strings that can appear in the shebang (#!) line to +# designate that it's part of the language. You can redefine strings found +# in the main languages file. +# +# Ignore Prefixes in Index: [prefix] [prefix] ... +# [Add/Replace] Ignored Prefixes in Index: [prefix] [prefix] ... +# +# Ignore [Topic Type] Prefixes in Index: [prefix] [prefix] ... +# [Add/Replace] Ignored [Topic Type] Prefixes in Index: [prefix] [prefix] ... +# Specifies prefixes that should be ignored when sorting symbols in an +# index. Can be specified in general or for a specific topic type. +# +#------------------------------------------------------------------------------ +# For basic language support only: +# +# Line Comments: [symbol] [symbol] ... +# Defines a space-separated list of symbols that are used for line comments, +# if any. +# +# Block Comments: [opening sym] [closing sym] [opening sym] [closing sym] ... +# Defines a space-separated list of symbol pairs that are used for block +# comments, if any. +# +# Package Separator: [symbol] +# Defines the default package separator symbol. The default is a dot. +# +# [Topic Type] Prototype Enders: [symbol] [symbol] ... +# When defined, Natural Docs will attempt to get a prototype from the code +# immediately following the topic type. It stops when it reaches one of +# these symbols. Use \n for line breaks. +# +# Line Extender: [symbol] +# Defines the symbol that allows a prototype to span multiple lines if +# normally a line break would end it. +# +# Enum Values: [global|under type|under parent] +# Defines how enum values are referenced. The default is global. +# global - Values are always global, referenced as 'value'. +# under type - Values are under the enum type, referenced as +# 'package.enum.value'. +# under parent - Values are under the enum's parent, referenced as +# 'package.value'. +# +# Perl Package: [perl package] +# Specifies the Perl package used to fine-tune the language behavior in ways +# too complex to do in this file. +# +#------------------------------------------------------------------------------ +# For full language support only: +# +# Full Language Support: [perl package] +# Specifies the Perl package that has the parsing routines necessary for full +# language support. +# +#------------------------------------------------------------------------------- + +# The following languages are defined in the main file, if you'd like to alter +# them: +# +# Text File, Shebang Script, C/C++, C#, Java, JavaScript, Perl, Python, +# PHP, SQL, Visual Basic, Pascal, Assembly, Ada, Tcl, Ruby, Makefile, +# ActionScript, ColdFusion, R, Fortran + +# If you add a language that you think would be useful to other developers +# and should be included in Natural Docs by default, please e-mail it to +# languages [at] naturaldocs [dot] org. diff --git a/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/project/Topics.txt b/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/project/Topics.txt new file mode 100644 index 00000000000..21530908d76 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/project/Topics.txt @@ -0,0 +1,81 @@ +Format: 1.51 + +# This is the Natural Docs topics file for this project. If you change anything +# here, it will apply to THIS PROJECT ONLY. If you'd like to change something +# for all your projects, edit the Topics.txt in Natural Docs' Config directory +# instead. + + +# If you'd like to prevent keywords from being recognized by Natural Docs, you +# can do it like this: +# Ignore Keywords: [keyword], [keyword], ... +# +# Or you can use the list syntax like how they are defined: +# Ignore Keywords: +# [keyword] +# [keyword], [plural keyword] +# ... + + +#------------------------------------------------------------------------------- +# SYNTAX: +# +# Topic Type: [name] +# Alter Topic Type: [name] +# Creates a new topic type or alters one from the main file. Each type gets +# its own index and behavior settings. Its name can have letters, numbers, +# spaces, and these charaters: - / . ' +# +# Plural: [name] +# Sets the plural name of the topic type, if different. +# +# Keywords: +# [keyword] +# [keyword], [plural keyword] +# ... +# Defines or adds to the list of keywords for the topic type. They may only +# contain letters, numbers, and spaces and are not case sensitive. Plural +# keywords are used for list topics. You can redefine keywords found in the +# main topics file. +# +# Index: [yes|no] +# Whether the topics get their own index. Defaults to yes. Everything is +# included in the general index regardless of this setting. +# +# Scope: [normal|start|end|always global] +# How the topics affects scope. Defaults to normal. +# normal - Topics stay within the current scope. +# start - Topics start a new scope for all the topics beneath it, +# like class topics. +# end - Topics reset the scope back to global for all the topics +# beneath it. +# always global - Topics are defined as global, but do not change the scope +# for any other topics. +# +# Class Hierarchy: [yes|no] +# Whether the topics are part of the class hierarchy. Defaults to no. +# +# Page Title If First: [yes|no] +# Whether the topic's title becomes the page title if it's the first one in +# a file. Defaults to no. +# +# Break Lists: [yes|no] +# Whether list topics should be broken into individual topics in the output. +# Defaults to no. +# +# Can Group With: [type], [type], ... +# Defines a list of topic types that this one can possibly be grouped with. +# Defaults to none. +#------------------------------------------------------------------------------- + +# The following topics are defined in the main file, if you'd like to alter +# their behavior or add keywords: +# +# Generic, Class, Interface, Section, File, Group, Function, Variable, +# Property, Type, Constant, Enumeration, Event, Delegate, Macro, +# Database, Database Table, Database View, Database Index, Database +# Cursor, Database Trigger, Cookie, Build Target + +# If you add something that you think would be useful to other developers +# and should be included in Natural Docs by default, please e-mail it to +# topics [at] naturaldocs [dot] org. diff --git a/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/run_docs.sh b/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/run_docs.sh new file mode 100755 index 00000000000..dfe1e62ebf8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/docs/naturaldocs/run_docs.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +set -e + +# Version number +VERSION=`(cd ../../; perl config/getver.pl)` + +# Clear away old docs and ensure the doc dir. is present. +[ -d html ] && rm -rf html +mkdir html + +# Create a lightly-processed copy of the source to use as input. This +# file skips all non-C code in src/ and removes the BGD_DECLARE() +# macro from definitions so they don't show up in the docs. +[ -d tmp ] && rm -rf tmp +mkdir tmp +perl nobgd.pl ../../src/ tmp/ + +# Add the external docs. +cp license.txt tmp/ +sed -e "s/@VERSION@/$VERSION/g" preamble.txt > tmp/preamble.txt +# ^^^ hack to get the version number in the docs. + +# Run naturaldocs to create the manual. +naturaldocs --rebuild --rebuild-output --documented-only \ + -i tmp/ \ + -o html html \ + --project project/ + +# And cleanup the temp files. +rm -rf Data tmp + + diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/examples/CMakeLists.txt new file mode 100644 index 00000000000..e31e67d408a --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/CMakeLists.txt @@ -0,0 +1,39 @@ +include_directories (BEFORE "${GD_SOURCE_DIR}/src" "${CMAKE_BINARY_DIR}") + +SET(TESTS_FILES + arc + crop + gif + nnquant + tgaread +) + +if (JPEG_FOUND) + LIST(APPEND TESTS_FILES copyrotated flip) +endif (JPEG_FOUND) + +if (TIFF_FOUND) + LIST(APPEND TESTS_FILES tiffread) +endif (TIFF_FOUND) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} ${GD_LIB}) +ENDFOREACH(test_name) + +if(JPEG_FOUND) + if(UNIX) + target_link_libraries(copyrotated m) + endif(UNIX) +endif(JPEG_FOUND) + +if (WIN32 AND NOT MINGW AND NOT MSYS) + add_executable(windows WIN32 "windows.c") + target_link_libraries (windows ${GD_LIB}) +else (WIN32 AND NOT MINGW AND NOT MSYS) + if (MINGW OR MSYS) + add_executable(windows "windows.c") + add_definitions("-mwindows") + target_link_libraries(windows ${GD_LIB} stdc++ gdi32) + endif (MINGW OR MSYS) +endif (WIN32 AND NOT MINGW AND NOT MSYS) diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/arc.c b/Build/source/libs/gd/libgd-2.1.1/examples/arc.c new file mode 100644 index 00000000000..8e862833855 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/arc.c @@ -0,0 +1,31 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> + +int main() +{ + gdImagePtr im; + FILE *fp; + int cor_rad = 60; + im = gdImageCreateTrueColor(400, 400); + gdImageFilledRectangle(im, 0, 0, 399, 399, 0x00FFFFFF); + + gdImageFilledArc (im, cor_rad, 399 - cor_rad, cor_rad *2, cor_rad *2, 90, 180, 0x0, gdPie); + + fp = fopen("b.png", "wb"); + if (!fp) { + fprintf(stderr, "Can't save png image.\n"); + gdImageDestroy(im); + return 1; + } +#ifdef HAVE_LIBPNG + gdImagePng(im, fp); +#else + printf("No PNG support. Cannot save image.\n"); +#endif + fclose(fp); + + gdImageDestroy(im); + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/copyrotated.c b/Build/source/libs/gd/libgd-2.1.1/examples/copyrotated.c new file mode 100644 index 00000000000..03e493d0ce0 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/copyrotated.c @@ -0,0 +1,91 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include <math.h> + +gdImagePtr loadImage(const char *name) +{ + FILE *fp; + gdImagePtr im; + + fp = fopen(name, "rb"); + if (!fp) { + fprintf(stderr, "Can't open jpeg file\n"); + return NULL; + } + + im = gdImageCreateFromJpeg(fp); + fclose(fp); + return im; +} + +int savePngImage(gdImagePtr im, const char *name) +{ + FILE *fp; + fp = fopen(name, "wb"); + if (!fp) { + fprintf(stderr, "Can't save png image fromtiff.png\n"); + return 0; + } + gdImagePng(im, fp); + fclose(fp); + return 1; +} + +int main(int argc, char **arg) +{ + gdImagePtr im, im2; + int new_width, new_height; + double angle, a2; + + if (argc < 3) { + fprintf(stderr, "Usage: copyrotated [angle in degree] [filename.png]\n"); + return 1; + } + angle = strtod(arg[1], 0); + im = loadImage(arg[2]); + + if (!im) { + fprintf(stderr, "Can't load PNG file <%s>", arg[1]); + return 1; + } + + /* + cos adj hyp (cos = adjacent / hypothenus) + sin op hyp (sin adjacent / hypothenus) + + 10 pixels margin + */ + + /* to radian */ + a2 = angle * .0174532925; + + new_width = ceil(cos(a2) * gdImageSX(im)) + + fabs(sin(a2) * gdImageSY(im)); + new_height = ceil(cos(a2) * gdImageSY(im)) + + fabs(sin(a2) * gdImageSX(im)); + + + im2 = gdImageCreateTrueColor(new_width, new_height); + if (!im2) { + fprintf(stderr, "Can't create a new image"); + gdImageDestroy(im); + return 1; + } + + gdImageAlphaBlending(im2, 0); + gdImageFilledRectangle(im2, 0, 0, gdImageSX(im2), gdImageSY(im2), gdTrueColorAlpha(127,0,0,127)); + + gdImageCopyRotated(im2, im, new_width/2, new_height/2, 0, 0, gdImageSX(im), gdImageSY(im), angle); + gdImageSaveAlpha(im2, 1); + if (!savePngImage(im2, "rotated.png")) { + fprintf(stderr, "Can't save PNG file rotated.png"); + gdImageDestroy(im); + gdImageDestroy(im2); + return 1; + } + + gdImageDestroy(im2); + gdImageDestroy(im); + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/crop.c b/Build/source/libs/gd/libgd-2.1.1/examples/crop.c new file mode 100644 index 00000000000..bafb6df849c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/crop.c @@ -0,0 +1,78 @@ +/* $Id$ */ + +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> + +void save_png(gdImagePtr im, const char *filename) +{ + FILE *fp; + fp = fopen(filename, "wb"); + if (!fp) { + fprintf(stderr, "Can't save png image %s\n", filename); + return; + } +#ifdef HAVE_LIBPNG + gdImagePng(im, fp); +#else + printf("No PNG support. Cannot save image.\n"); +#endif + fclose(fp); +} + +gdImagePtr read_png(const char *filename) +{ + FILE * fp; + gdImagePtr im; + + fp = fopen(filename, "rb"); + if (!fp) { + fprintf(stderr, "Can't read png image %s\n", filename); + return NULL; + } +#ifdef HAVE_LIBPNG + im = gdImageCreateFromPng(fp); +#else + im = NULL; + printf("No PNG support. Cannot read image.\n"); +#endif + fclose(fp); + return im; +} + +int main() +{ + gdImagePtr im, im2; + + im = gdImageCreateTrueColor(400, 400); + + if (!im) { + fprintf(stderr, "Can't create 400x400 TC image\n"); + return 1; + } + + gdImageFilledRectangle(im, 19, 29, 390, 390, 0xFFFFFF); + gdImageRectangle(im, 19, 29, 390, 390, 0xFF0000); + save_png(im, "a1.png"); + + im2 = gdImageCropAuto(im, GD_CROP_SIDES); + if (im2) { + save_png(im2, "a2.png"); + gdImageDestroy(im2); + } + gdImageDestroy(im); + + im = read_png("test_crop_threshold.png"); + if (!im) { + return 1; + } + + im2 = gdImageCropThreshold(im, 0xFFFFFF, 0.6); + if (im2) { + save_png(im2, "a4.png"); + gdImageDestroy(im2); + } + + gdImageDestroy(im); + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/flip.c b/Build/source/libs/gd/libgd-2.1.1/examples/flip.c new file mode 100644 index 00000000000..2399457b81b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/flip.c @@ -0,0 +1,75 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +gdImagePtr loadImage(const char *name) +{ + FILE *fp; + gdImagePtr im; + + fp = fopen(name, "rb"); + if (!fp) { + fprintf(stderr, "Can't open jpeg file\n"); + return NULL; + } + + im = gdImageCreateFromJpeg(fp); + fclose(fp); + return im; +} + +int savePngImage(gdImagePtr im, const char *name) +{ + FILE *fp; + fp = fopen(name, "wb"); + if (!fp) { + fprintf(stderr, "Can't save png image fromtiff.png\n"); + return 0; + } + gdImagePng(im, fp); + fclose(fp); + return 1; +} + +int main(int argc, char **arg) +{ + gdImagePtr im; + int returncode = 0; + + if (argc < 2) { + fprintf(stderr, "Usage: flip [filename.png]\n"); + return 1; + } + + im = loadImage(arg[1]); + if (!im) goto error; + gdImageFlipHorizontal(im); + if (!savePngImage(im, "flip_horizontal.png")) { + goto error; + } + gdImageDestroy(im); + + im = loadImage(arg[1]); + if (!im) goto error; + gdImageFlipVertical(im); + if (!savePngImage(im, "flip_vertical.png")) { + goto error; + } + gdImageDestroy(im); + + im = loadImage(arg[1]); + if (!im) goto error; + gdImageFlipBoth(im); + if (!savePngImage(im, "flip_both.png")) { + goto error; + } + gdImageDestroy(im); + + goto done; + +error: + returncode = 1; + +done: + return returncode; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/gif.c b/Build/source/libs/gd/libgd-2.1.1/examples/gif.c new file mode 100644 index 00000000000..d5103f086b3 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/gif.c @@ -0,0 +1,52 @@ +#include <stdio.h> +#include <stdlib.h> +#include <gd.h> + +int main(void) +{ + int i; + FILE * out; + + gdImagePtr im; + gdImagePtr prev =NULL; + int black; + + im = gdImageCreate(100, 100); + if (!im) { + fprintf(stderr, "can't create image"); + return 1; + } + + out = fopen("anim.gif", "wb"); + if (!out) { + fprintf(stderr, "can't create file %s", "anim.gif"); + return 1; + } + + gdImageColorAllocate(im, 255, 255, 255); /* allocate white as side effect */ + gdImageGifAnimBegin(im, out, 1, -1); + + for(i = 0; i < 20; i++) { + int r,g,b; + im = gdImageCreate(100, 100); + r = rand() % 255; + g = rand() % 255; + b = rand() % 255; + + gdImageColorAllocate(im, 255, 255, 255); /* allocate white as side effect */ + black = gdImageColorAllocate(im, r, g, b); + printf("(%i, %i, %i)\n",r, g, b); + gdImageFilledRectangle(im, rand() % 100, rand() % 100, rand() % 100, rand() % 100, black); + gdImageGifAnimAdd(im, out, 1, 0, 0, 10, 1, prev); + + if(prev) { + gdImageDestroy(prev); + } + prev = im; + } + + gdImageGifAnimEnd(out); + fclose(out); + + return 0; +}
\ No newline at end of file diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/nnquant.c b/Build/source/libs/gd/libgd-2.1.1/examples/nnquant.c new file mode 100644 index 00000000000..33ed523266e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/nnquant.c @@ -0,0 +1,64 @@ +/* $Id$ */ + +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> + +void save_png(gdImagePtr im, const char *filename) +{ + FILE *fp; + fp = fopen(filename, "wb"); + if (!fp) { + fprintf(stderr, "Can't save png image %s\n", filename); + return; + } +#ifdef HAVE_LIBPNG + gdImagePng(im, fp); +#else + printf("No PNG support. Cannot save image.\n"); +#endif + fclose(fp); +} + +int main() +{ +#ifdef HAVE_JPEG + gdImagePtr im, im2; + FILE *fp; + char path[2048]; + + fp=fopen("resampledbug.jpeg", "rb"); + if (!fp) { + fprintf(stderr, "Can't load /home/pierre/IM3801.jpg\n"); + return 1; + } + + im = gdImageCreateFromJpeg(fp); + fclose(fp); + if (!im) { + fprintf(stderr, "Can't load TIFF image %s\n", path); + return 1; + } + + im2 = gdImageNeuQuant(im, 256, 3); + + if (im2) { + gdImageSaveAlpha(im2, 1); + save_png(im2, "a_nnquant.png"); + gdImageDestroy(im2); + } else { + printf("neu quant failed.\n"); + } + + gdImageTrueColorToPalette(im, 1, 256); + + gdImageSaveAlpha(im, 1); + save_png(im, "a_jquant_dither.png"); + + gdImageDestroy(im); +#else + printf("JPEG support is required for this example. Please recompile GD with JPEG or change this example to use another format as input."); + return 1; +#endif + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/noIcon.pic b/Build/source/libs/gd/libgd-2.1.1/examples/noIcon.pic Binary files differnew file mode 100644 index 00000000000..8335d3a2a28 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/noIcon.pic diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/noIcon.sgi b/Build/source/libs/gd/libgd-2.1.1/examples/noIcon.sgi Binary files differnew file mode 100644 index 00000000000..98aac523c10 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/noIcon.sgi diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/noIcon.tga b/Build/source/libs/gd/libgd-2.1.1/examples/noIcon.tga Binary files differnew file mode 100644 index 00000000000..7063fac97bf --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/noIcon.tga diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/noIconAlpha.tga b/Build/source/libs/gd/libgd-2.1.1/examples/noIconAlpha.tga Binary files differnew file mode 100644 index 00000000000..3af87b47b67 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/noIconAlpha.tga diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/resize.c b/Build/source/libs/gd/libgd-2.1.1/examples/resize.c new file mode 100644 index 00000000000..84543cd434b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/resize.c @@ -0,0 +1,59 @@ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> + +int main (int argc, char *argv[]) { + FILE *fp; + gdImagePtr in, out; + int w, h; + + /* Help */ + if (argc<=4) { + printf("%s input.jpg output.jpg width height\n", argv[0]); + return 1; + } + + /* Size */ + w = atoi(argv[3]); + h = atoi(argv[4]); + if (w<=0 || h<=0) { + fprintf(stderr, "Bad size %dx%d\n", h, w); + return 2; + } + + /* Input */ + fp = fopen(argv[1], "rb"); + if (!fp) { + fprintf(stderr, "Can't read image %s\n", argv[1]); + return 3; + } + in = gdImageCreateFromJpeg(fp); + fclose(fp); + if (!in) { + fprintf(stderr, "Can't create image from %s\n", argv[1]); + return 4; + } + + /* Resize */ + gdImageSetInterpolationMethod(in, GD_BILINEAR_FIXED); + out = gdImageScale(in, w, h); + if (!out) { + fprintf(stderr, "gdImageScale fails\n"); + return 5; + } + + /* Output */ + fp = fopen(argv[2], "wb"); + if (!fp) { + fprintf(stderr, "Can't save image %s\n", argv[2]); + return 6; + } + gdImageJpeg(out, fp, 90); + fclose(fp); + + /* Cleanups */ + gdImageDestroy(in); + gdImageDestroy(out); + + return 0; +}
\ No newline at end of file diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/test_crop_threshold.png b/Build/source/libs/gd/libgd-2.1.1/examples/test_crop_threshold.png Binary files differnew file mode 100644 index 00000000000..4a9dff1a815 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/test_crop_threshold.png diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/tgaread.c b/Build/source/libs/gd/libgd-2.1.1/examples/tgaread.c new file mode 100644 index 00000000000..a8e080782b2 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/tgaread.c @@ -0,0 +1,56 @@ +/* $Id$ */ +/* + * You can fetch a set of samples TIFF images here: + * ftp://ftp.remotesensing.org/pub/libtiff/ + * (pics-x.y.z.tar.gz) + */ + +#include <gd.h> +#include <stdio.h> +#include <stdlib.h> + +int main() +{ + gdImagePtr im; + FILE *fp; + char path[4][2048]; + int i; + char dst[2048]; + + sprintf(path[0], "noIconAlpha.tga"); + sprintf(path[1], "noIcon.tga"); + + for (i = 0; i < 2; i++) { + printf("opening %s\n", path[i]); + fp = fopen(path[i], "rb"); + if (!fp) { + printf("failed, cannot open file\n"); + return 1; + } + + im = gdImageCreateFromTga(fp); + fclose(fp); + if (!im) { + fprintf(stderr, "Can't load TIFF image %s\n", path[i]); + return 1; + } + + + sprintf(dst, "%i.png", i); + + fp = fopen(dst, "wb"); + if (!fp) { + fprintf(stderr, "Can't save png image fromtiff.png\n"); + gdImageDestroy(im); + return 1; + } +#ifdef HAVE_LIBPNG + gdImagePng(im, fp); +#else + printf("No PNG support. Cannot save image.\n"); +#endif + fclose(fp); + gdImageDestroy(im); + } + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/tiffread.c b/Build/source/libs/gd/libgd-2.1.1/examples/tiffread.c new file mode 100644 index 00000000000..fe63ce00b2c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/tiffread.c @@ -0,0 +1,59 @@ +/* $Id$ */ +/* + * You can fetch a set of samples TIFF images here: + * ftp://ftp.remotesensing.org/pub/libtiff/ + * (pics-x.y.z.tar.gz) + */ + +#include <gd.h> +#include <stdio.h> +#include <stdlib.h> +int main() +{ + gdImagePtr im; + FILE *fp; + char path[9][2048]; + int i; + char dst[2048]; + + sprintf(path[0], "cramps-tile.tif"); + sprintf(path[1], "cramps.tif"); + sprintf(path[2], "ycbcr-cat.tif"); + sprintf(path[3], "jello.tif"); + sprintf(path[4], "caspian.tif"); + sprintf(path[5], "strike.tif"); + sprintf(path[6], "off_luv24.tif"); + sprintf(path[7], "off_l16.tif"); + sprintf(path[8], "fax2d.tif"); + + for (i = 0; i < 9; i++) { + printf("opening %s\n", path[i]); + fp = fopen(path[i], "rb"); + if (!fp) { + printf("failed, cannot open file\n"); + return 1; + } + + im = gdImageCreateFromTiff(fp); + fclose(fp); + if (!im) { + fprintf(stderr, "Can't load TIFF image %s\n", path[i]); + return 1; + } + + + sprintf(dst, "%i.png", i); + + fp = fopen(dst, "wb"); + if (!fp) { + fprintf(stderr, "Can't save png image fromtiff.png\n"); + gdImageDestroy(im); + return 1; + } + + gdImagePng(im, fp); + fclose(fp); + gdImageDestroy(im); + } + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/examples/windows.c b/Build/source/libs/gd/libgd-2.1.1/examples/windows.c new file mode 100644 index 00000000000..55976386f4e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/examples/windows.c @@ -0,0 +1,311 @@ +/* +Sample usage of GD on windows. This little program opens a window, fetch its DIB +and assigns to a GD truecolor image. + +Thanks to Mateusz Loskot (http://mateusz.loskot.net) for the AttachBuffer function! +$Id$ +*/ +#include <windows.h> +#include <gd.h> +#include <gdfontg.h> +#include <gdfontl.h> + + +gdImagePtr gdImageTrueColorAttachBuffer(int* buffer, int sx, int sy, int stride) +{ + int i; + int height; + int* rowptr; + gdImagePtr im; + im = (gdImage *) malloc (sizeof (gdImage)); + if (!im) { + return 0; + } + memset (im, 0, sizeof (gdImage)); + +#if 0 + if (overflow2(sizeof (int *), sy)) { + return 0; + } +#endif + + im->tpixels = (int **) malloc (sizeof (int *) * sy); + if (!im->tpixels) { + free(im); + return 0; + } + + im->polyInts = 0; + im->polyAllocated = 0; + im->brush = 0; + im->tile = 0; + im->style = 0; + + height = sy; + rowptr = buffer; + if (stride < 0) { + int startoff = (height - 1) * stride; + rowptr = buffer - startoff; + } + + i = 0; + while (height--) { + im->tpixels[i] = rowptr; + rowptr += stride; + i++; + } + + im->sx = sx; + im->sy = sy; + im->transparent = (-1); + im->interlace = 0; + im->trueColor = 1; + im->saveAlphaFlag = 0; + im->alphaBlendingFlag = 1; + im->thick = 1; + im->AA = 0; + im->cx1 = 0; + im->cy1 = 0; + im->cx2 = im->sx - 1; + im->cy2 = im->sy - 1; + return im; +} + +void gdImageDetachBuffer(gdImagePtr im) +{ + free(im->tpixels); + free(im); +} + + +BITMAPINFO gdCreateBmp(int width, int height) +{ + BITMAPINFO bmp_info; + + // Configure bitmap properties + + ZeroMemory(&bmp_info, sizeof(BITMAPINFO)); + bmp_info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + bmp_info.bmiHeader.biWidth = width; + bmp_info.bmiHeader.biHeight = height; + bmp_info.bmiHeader.biPlanes = 1; + bmp_info.bmiHeader.biBitCount = 32; + bmp_info.bmiHeader.biCompression = BI_RGB; + bmp_info.bmiHeader.biSizeImage = 0; + bmp_info.bmiHeader.biXPelsPerMeter = 0; + bmp_info.bmiHeader.biYPelsPerMeter = 0; + bmp_info.bmiHeader.biClrUsed = 0; + bmp_info.bmiHeader.biClrImportant = 0; + return bmp_info; +} + +LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ; + +int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, + PSTR szCmdLine, int iCmdShow) +{ + static TCHAR szAppName[] = TEXT ("Bezier") ; + HWND hwnd ; + MSG msg ; + WNDCLASS wndclass ; + + wndclass.style = CS_HREDRAW | CS_VREDRAW ; + wndclass.lpfnWndProc = WndProc ; + wndclass.cbClsExtra = 0 ; + wndclass.cbWndExtra = 0 ; + wndclass.hInstance = hInstance ; + wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION) ; + wndclass.hCursor = LoadCursor (NULL, IDC_ARROW) ; + wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ; + wndclass.lpszMenuName = NULL ; + wndclass.lpszClassName = szAppName ; + + if (!RegisterClass (&wndclass)) { + // UNICODE-Compilierung ist die einzige realistische Fehlermöglichkeit + MessageBox (NULL, TEXT ("Programm arbeitet mit Unicode und setzt Windows NT voraus!"), + szAppName, MB_ICONERROR) ; + return 0 ; + } + + hwnd = CreateWindow (szAppName, TEXT ("Bezierkurven"), + WS_OVERLAPPEDWINDOW, + CW_USEDEFAULT, CW_USEDEFAULT, + CW_USEDEFAULT, CW_USEDEFAULT, + NULL, NULL, hInstance, NULL) ; + + ShowWindow (hwnd, iCmdShow) ; + UpdateWindow (hwnd) ; + + while (GetMessage (&msg, NULL, 0, 0)) { + TranslateMessage (&msg) ; + DispatchMessage (&msg) ; + } + return msg.wParam ; +} + +void DrawBezier (HDC hdc, POINT apt[]) +{ + PolyBezier (hdc, apt, 4) ; + + MoveToEx (hdc, apt[0].x, apt[0].y, NULL) ; + LineTo (hdc, apt[1].x, apt[1].y) ; + + MoveToEx (hdc, apt[2].x, apt[2].y, NULL) ; + LineTo (hdc, apt[3].x, apt[3].y) ; +} + + +void gdDrawImage(HDC hdc, RECT *rc) +{ + HDC mem_dc; + BITMAPINFO bmp_info; + void* bits; + HBITMAP bmp, temp; + gdImagePtr im; + int width, height, stride; + int white, black, blue, red; + char *s = "Hello world!"; + gdFontPtr lfont, gfont; + + width = rc->right - rc->left; + height = rc->bottom - rc->top; + + bmp_info = gdCreateBmp(width, height); + + // Create memory device context + mem_dc = CreateCompatibleDC(hdc); + if (!mem_dc) { + MessageBox(NULL, "Can't create a compatible DC!", "Error!", MB_ICONEXCLAMATION | MB_OK); + return; + } + + // bits points to a shared buffer of pixels + bits = NULL; + bmp = CreateDIBSection(mem_dc, &bmp_info, DIB_RGB_COLORS, (void**)&bits, 0, 0); + + // Selecting the object before doing anything allows you to use libgd + // together with native Windows GDI. + temp = (HBITMAP)SelectObject(mem_dc, bmp); + + /*stride = ((width * 1 + 3) >> 2) << 2;*/ + // always uses 32bit in BMPINFO + stride = width; + im = NULL; + + // Attach shared buffer of pixels to GD image + // Negative stride places 0,0 in upper-left corner + im = gdImageTrueColorAttachBuffer((int*)bits, width, height, -stride); + if (!im) { + MessageBox(NULL, "GD image creation failed!", "Error!", MB_ICONEXCLAMATION | MB_OK); + return; + } + + // Start of GD drawing + white = gdImageColorAllocate(im, 255, 255, 255); + black = gdImageColorAllocate(im, 0, 0, 0); + blue = gdImageColorAllocate(im, 0, 0, 255); + + // Allocate the color red, 50% transparent. + red = gdImageColorAllocateAlpha(im, 255, 0, 0, 64); + + // Erase background with white color + gdImageFilledRectangle(im, 0, 0, width, height, 0xFF0000); + + lfont = gdFontGetLarge(); + gfont = gdFontGetGiant(); + + // Draw a dashed line from the upper left corner to the lower right corner. + gdImageFilledRectangle(im, 25, 25, 100, 100, blue); + + gdImageChar(im, gfont, 35, 35, 'Q', white); + gdImageFilledRectangle(im, 50, 50, 75, 175, red); + gdImageLine(im, 0, 0, 150, 150, black); + + gdImageString(im, gdFontGetLarge(), + im->sx / 2 - (strlen(s) * lfont->w / 2), + im->sy / 2 - lfont->h / 2, + (unsigned char*)s, black); + + // Copy drawing from memory context (shared bitmap buffer) to screen DC. + BitBlt(hdc, rc->left, rc->top, width, height, mem_dc, 0, 0, SRCCOPY); + + // Free + gdImageDetachBuffer(im); + SelectObject(mem_dc, temp); + DeleteObject(bmp); + DeleteObject(mem_dc); +} + +LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) +{ + static POINT apt[4] ; + HDC hdc ; + int cxClient, cyClient ; + PAINTSTRUCT ps ; + RECT rc; + + GetClientRect(hwnd, &rc); + + switch (message) { + case WM_SIZE: + cxClient = LOWORD (lParam) ; + cyClient = HIWORD (lParam) ; + + apt[0].x = cxClient / 4 ; + apt[0].y = cyClient / 2 ; + + apt[1].x = cxClient / 2 ; + apt[1].y = cyClient / 4 ; + + apt[2].x = cxClient / 2 ; + apt[2].y = 3 * cyClient / 4 ; + + apt[3].x = 3 * cxClient / 4 ; + apt[3].y = cyClient / 2 ; + return 0 ; + + case WM_LBUTTONDOWN: + case WM_RBUTTONDOWN: + case WM_MOUSEMOVE: + if (wParam & MK_LBUTTON || wParam & MK_RBUTTON) { + hdc = GetDC (hwnd) ; + + // alte Kurve löschen (mit Weiß übermalen) + SelectObject (hdc, GetStockObject (WHITE_PEN)) ; + DrawBezier (hdc, apt) ; + + if (wParam & MK_LBUTTON) { + apt[1].x = LOWORD (lParam) ; + apt[1].y = HIWORD (lParam) ; + } + + if (wParam & MK_RBUTTON) { + apt[2].x = LOWORD (lParam) ; + apt[2].y = HIWORD (lParam) ; + } + + // neue Kurve (mit Schwarz) zeichnen + SelectObject (hdc, GetStockObject (BLACK_PEN)) ; + gdDrawImage(hdc, &rc); + DrawBezier (hdc, apt) ; + ReleaseDC (hwnd, hdc) ; + } + return 0 ; + + + case WM_PAINT: + hdc = BeginPaint (hwnd, &ps) ; + + GetClientRect(hwnd, &rc); + gdDrawImage(hdc, &rc); + DrawBezier (hdc, apt) ; + + EndPaint (hwnd, &ps) ; + return 0 ; + + case WM_DESTROY: + PostQuitMessage (0) ; + return 0 ; + } + return DefWindowProc (hwnd, message, wParam, lParam) ; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/m4/ax_pthread.m4 b/Build/source/libs/gd/libgd-2.1.1/m4/ax_pthread.m4 new file mode 100644 index 00000000000..6d400ed4e8e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/m4/ax_pthread.m4 @@ -0,0 +1,317 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_pthread.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]]) +# +# DESCRIPTION +# +# This macro figures out how to build C programs using POSIX threads. It +# sets the PTHREAD_LIBS output variable to the threads library and linker +# flags, and the PTHREAD_CFLAGS output variable to any special C compiler +# flags that are needed. (The user can also force certain compiler +# flags/libs to be tested by setting these environment variables.) +# +# Also sets PTHREAD_CC to any special C compiler that is needed for +# multi-threaded programs (defaults to the value of CC otherwise). (This +# is necessary on AIX to use the special cc_r compiler alias.) +# +# NOTE: You are assumed to not only compile your program with these flags, +# but also link it with them as well. e.g. you should link with +# $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS +# +# If you are only building threads programs, you may wish to use these +# variables in your default LIBS, CFLAGS, and CC: +# +# LIBS="$PTHREAD_LIBS $LIBS" +# CFLAGS="$CFLAGS $PTHREAD_CFLAGS" +# CC="$PTHREAD_CC" +# +# In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant +# has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to that name +# (e.g. PTHREAD_CREATE_UNDETACHED on AIX). +# +# Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the +# PTHREAD_PRIO_INHERIT symbol is defined when compiling with +# PTHREAD_CFLAGS. +# +# ACTION-IF-FOUND is a list of shell commands to run if a threads library +# is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it +# is not found. If ACTION-IF-FOUND is not specified, the default action +# will define HAVE_PTHREAD. +# +# Please let the authors know if this macro fails on any platform, or if +# you have any other suggestions or comments. This macro was based on work +# by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help +# from M. Frigo), as well as ac_pthread and hb_pthread macros posted by +# Alejandro Forero Cuervo to the autoconf macro repository. We are also +# grateful for the helpful feedback of numerous users. +# +# Updated for Autoconf 2.68 by Daniel Richard G. +# +# LICENSE +# +# Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu> +# Copyright (c) 2011 Daniel Richard G. <skunk@iSKUNK.ORG> +# +# This program is free software: you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation, either version 3 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program. If not, see <http://www.gnu.org/licenses/>. +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Archive. When you make and distribute a +# modified version of the Autoconf Macro, you may extend this special +# exception to the GPL to apply to your modified version as well. + +#serial 20 + +AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD]) +AC_DEFUN([AX_PTHREAD], [ +AC_REQUIRE([AC_CANONICAL_HOST]) +AC_LANG_PUSH([C]) +ax_pthread_ok=no + +# We used to check for pthread.h first, but this fails if pthread.h +# requires special compiler flags (e.g. on True64 or Sequent). +# It gets checked for in the link test anyway. + +# First of all, check if the user has set any of the PTHREAD_LIBS, +# etcetera environment variables, and if threads linking works using +# them: +if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then + save_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS $PTHREAD_CFLAGS" + save_LIBS="$LIBS" + LIBS="$PTHREAD_LIBS $LIBS" + AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS]) + AC_TRY_LINK_FUNC(pthread_join, ax_pthread_ok=yes) + AC_MSG_RESULT($ax_pthread_ok) + if test x"$ax_pthread_ok" = xno; then + PTHREAD_LIBS="" + PTHREAD_CFLAGS="" + fi + LIBS="$save_LIBS" + CFLAGS="$save_CFLAGS" +fi + +# We must check for the threads library under a number of different +# names; the ordering is very important because some systems +# (e.g. DEC) have both -lpthread and -lpthreads, where one of the +# libraries is broken (non-POSIX). + +# Create a list of thread flags to try. Items starting with a "-" are +# C compiler flags, and other items are library names, except for "none" +# which indicates that we try without any flags at all, and "pthread-config" +# which is a program returning the flags for the Pth emulation library. + +ax_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config" + +# The ordering *is* (sometimes) important. Some notes on the +# individual items follow: + +# pthreads: AIX (must check this before -lpthread) +# none: in case threads are in libc; should be tried before -Kthread and +# other compiler flags to prevent continual compiler warnings +# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) +# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) +# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread) +# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads) +# -pthreads: Solaris/gcc +# -mthreads: Mingw32/gcc, Lynx/gcc +# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it +# doesn't hurt to check since this sometimes defines pthreads too; +# also defines -D_REENTRANT) +# ... -mt is also the pthreads flag for HP/aCC +# pthread: Linux, etcetera +# --thread-safe: KAI C++ +# pthread-config: use pthread-config program (for GNU Pth library) + +case ${host_os} in + solaris*) + + # On Solaris (at least, for some versions), libc contains stubbed + # (non-functional) versions of the pthreads routines, so link-based + # tests will erroneously succeed. (We need to link with -pthreads/-mt/ + # -lpthread.) (The stubs are missing pthread_cleanup_push, or rather + # a function called by this macro, so we could check for that, but + # who knows whether they'll stub that too in a future libc.) So, + # we'll just look for -pthreads and -lpthread first: + + ax_pthread_flags="-pthreads pthread -mt -pthread $ax_pthread_flags" + ;; + + darwin*) + ax_pthread_flags="-pthread $ax_pthread_flags" + ;; +esac + +if test x"$ax_pthread_ok" = xno; then +for flag in $ax_pthread_flags; do + + case $flag in + none) + AC_MSG_CHECKING([whether pthreads work without any flags]) + ;; + + -*) + AC_MSG_CHECKING([whether pthreads work with $flag]) + PTHREAD_CFLAGS="$flag" + ;; + + pthread-config) + AC_CHECK_PROG(ax_pthread_config, pthread-config, yes, no) + if test x"$ax_pthread_config" = xno; then continue; fi + PTHREAD_CFLAGS="`pthread-config --cflags`" + PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`" + ;; + + *) + AC_MSG_CHECKING([for the pthreads library -l$flag]) + PTHREAD_LIBS="-l$flag" + ;; + esac + + save_LIBS="$LIBS" + save_CFLAGS="$CFLAGS" + LIBS="$PTHREAD_LIBS $LIBS" + CFLAGS="$CFLAGS $PTHREAD_CFLAGS" + + # Check for various functions. We must include pthread.h, + # since some functions may be macros. (On the Sequent, we + # need a special flag -Kthread to make this header compile.) + # We check for pthread_join because it is in -lpthread on IRIX + # while pthread_create is in libc. We check for pthread_attr_init + # due to DEC craziness with -lpthreads. We check for + # pthread_cleanup_push because it is one of the few pthread + # functions on Solaris that doesn't have a non-functional libc stub. + # We try pthread_create on general principles. + AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h> + static void routine(void *a) { a = 0; } + static void *start_routine(void *a) { return a; }], + [pthread_t th; pthread_attr_t attr; + pthread_create(&th, 0, start_routine, 0); + pthread_join(th, 0); + pthread_attr_init(&attr); + pthread_cleanup_push(routine, 0); + pthread_cleanup_pop(0) /* ; */])], + [ax_pthread_ok=yes], + []) + + LIBS="$save_LIBS" + CFLAGS="$save_CFLAGS" + + AC_MSG_RESULT($ax_pthread_ok) + if test "x$ax_pthread_ok" = xyes; then + break; + fi + + PTHREAD_LIBS="" + PTHREAD_CFLAGS="" +done +fi + +# Various other checks: +if test "x$ax_pthread_ok" = xyes; then + save_LIBS="$LIBS" + LIBS="$PTHREAD_LIBS $LIBS" + save_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS $PTHREAD_CFLAGS" + + # Detect AIX lossage: JOINABLE attribute is called UNDETACHED. + AC_MSG_CHECKING([for joinable pthread attribute]) + attr_name=unknown + for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do + AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>], + [int attr = $attr; return attr /* ; */])], + [attr_name=$attr; break], + []) + done + AC_MSG_RESULT($attr_name) + if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then + AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name, + [Define to necessary symbol if this constant + uses a non-standard name on your system.]) + fi + + AC_MSG_CHECKING([if more special flags are required for pthreads]) + flag=no + case ${host_os} in + aix* | freebsd* | darwin*) flag="-D_THREAD_SAFE";; + osf* | hpux*) flag="-D_REENTRANT";; + solaris*) + if test "$GCC" = "yes"; then + flag="-D_REENTRANT" + else + flag="-mt -D_REENTRANT" + fi + ;; + esac + AC_MSG_RESULT(${flag}) + if test "x$flag" != xno; then + PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS" + fi + + AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT], + ax_cv_PTHREAD_PRIO_INHERIT, [ + AC_LINK_IFELSE([ + AC_LANG_PROGRAM([[#include <pthread.h>]], [[int i = PTHREAD_PRIO_INHERIT;]])], + [ax_cv_PTHREAD_PRIO_INHERIT=yes], + [ax_cv_PTHREAD_PRIO_INHERIT=no]) + ]) + AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes"], + AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], 1, [Have PTHREAD_PRIO_INHERIT.])) + + LIBS="$save_LIBS" + CFLAGS="$save_CFLAGS" + + # More AIX lossage: compile with *_r variant + if test "x$GCC" != xyes; then + case $host_os in + aix*) + AS_CASE(["x/$CC"], + [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6], + [#handle absolute path differently from PATH based program lookup + AS_CASE(["x$CC"], + [x/*], + [AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])], + [AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])])]) + ;; + esac + fi +fi + +test -n "$PTHREAD_CC" || PTHREAD_CC="$CC" + +AC_SUBST(PTHREAD_LIBS) +AC_SUBST(PTHREAD_CFLAGS) +AC_SUBST(PTHREAD_CC) + +# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND: +if test x"$ax_pthread_ok" = xyes; then + ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1]) + : +else + ax_pthread_ok=no + $2 +fi +AC_LANG_POP +])dnl AX_PTHREAD diff --git a/Build/source/libs/gd/libgd-2.1.1/m4/visibility.m4 b/Build/source/libs/gd/libgd-2.1.1/m4/visibility.m4 new file mode 100644 index 00000000000..2ff6330aa42 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/m4/visibility.m4 @@ -0,0 +1,52 @@ +# visibility.m4 serial 1 (gettext-0.15) +dnl Copyright (C) 2005 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +dnl From Bruno Haible. + +dnl Tests whether the compiler supports the command-line option +dnl -fvisibility=hidden and the function and variable attributes +dnl __attribute__((__visibility__("hidden"))) and +dnl __attribute__((__visibility__("default"))). +dnl Does *not* test for __visibility__("protected") - which has tricky +dnl semantics (see the 'vismain' test in glibc) and does not exist e.g. on +dnl MacOS X. +dnl Does *not* test for __visibility__("internal") - which has processor +dnl dependent semantics. +dnl Does *not* test for #pragma GCC visibility push(hidden) - which is +dnl "really only recommended for legacy code". +dnl Set the variable CFLAG_VISIBILITY. +dnl Defines and sets the variable HAVE_VISIBILITY. + +AC_DEFUN([gl_VISIBILITY], +[ + AC_REQUIRE([AC_PROG_CC]) + CFLAG_VISIBILITY= + HAVE_VISIBILITY=0 + if test -n "$GCC"; then + AC_MSG_CHECKING([for simple visibility declarations]) + AC_CACHE_VAL(gl_cv_cc_visibility, [ + gl_save_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -fvisibility=hidden" + AC_TRY_COMPILE( + [extern __attribute__((__visibility__("hidden"))) int hiddenvar; + extern __attribute__((__visibility__("default"))) int exportedvar; + extern __attribute__((__visibility__("hidden"))) int hiddenfunc (void); + extern __attribute__((__visibility__("default"))) int exportedfunc (void);], + [], + gl_cv_cc_visibility=yes, + gl_cv_cc_visibility=no) + CFLAGS="$gl_save_CFLAGS"]) + AC_MSG_RESULT([$gl_cv_cc_visibility]) + if test $gl_cv_cc_visibility = yes; then + CFLAG_VISIBILITY="-fvisibility=hidden" + HAVE_VISIBILITY=1 + fi + fi + AC_SUBST([CFLAG_VISIBILITY]) + AC_SUBST([HAVE_VISIBILITY]) + AC_DEFINE_UNQUOTED([HAVE_VISIBILITY], [$HAVE_VISIBILITY], + [Define to 1 or 0, depending whether the compiler supports simple visibility declarations.]) +]) diff --git a/Build/source/libs/gd/libgd-2.1.1/m4/w32.m4 b/Build/source/libs/gd/libgd-2.1.1/m4/w32.m4 new file mode 100644 index 00000000000..fbcc541d969 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/m4/w32.m4 @@ -0,0 +1,11 @@ +# MINGW_AC_WIN32_NATIVE_HOST +# -------------------------- +# Check if the runtime platform is a native Win32 host. +# +AC_DEFUN([MINGW_AC_WIN32_NATIVE_HOST], +[AC_CACHE_CHECK([whether we are building for a Win32 host], [mingw_cv_win32_host], + AC_COMPILE_IFELSE([AC_LANG_SOURCE([[ +#ifdef _WIN32 + choke me +#endif]])], [mingw_cv_win32_host=no], [mingw_cv_win32_host=yes]))dnl +])# MINGW_AC_WIN32_NATIVE_HOST diff --git a/Build/source/libs/gd/libgd-2.1.1/netware/Makefile.netware b/Build/source/libs/gd/libgd-2.1.1/netware/Makefile.netware new file mode 100644 index 00000000000..3da624349f5 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/netware/Makefile.netware @@ -0,0 +1,553 @@ +################################################################# +# +## Makefile for building libgd.nlm (NetWare version - gnu make) +## Use: make -f Makefile +## +## Comments to: Guenter Knauf <eflash@gmx.net> +## +## $Id$ +# +################################################################# + +# Edit the path below to point to the base of your Novell NDK. +ifndef NDKBASE +NDKBASE = c:/novell +endif + +# Base for the lib sources +ifndef LIBBASE +LIBBASE = ../.. +endif +# All library code is statically linked to avoid problems with other lib NLMs. + +# Edit the path below to point to your libpng sources or set environment var. +ifndef LIBPNG +LIBPNG = $(LIBBASE)/libpng-1.2.16 +endif +# Edit the path below to point to your libpng sources or set environment var. +ifndef LIBJPEG +LIBJPEG = $(LIBBASE)/jpeg-6b +endif +# Edit the path below to point to your freetype sources or set environment var. +ifndef LIBFT2 +LIBFT2 = $(LIBBASE)/freetype-2.3.4 +endif +# Edit the path below to point to your zlib sources or set environment var. +ifndef ZLIBSDK +ZLIBSDK = $(LIBBASE)/zlib-1.2.3 +endif + +LIBGD = .. + +ifndef INSTDIR +INSTDIR = libgd-$(LIBGD_VERSION_STR)-bin-nw +endif + +# Edit the vars below to change NLM target settings. +TARGET = libgd +COPYR = Copyright (C) 1996-2007 Boutell.Com, Inc. +WWW = http://www.libgd.org/ +DESCR = libgd $(LIBGD_VERSION_STR) - $(WWW) +MTSAFE = YES +STACK = 64000 +SCREEN = none +EXPORTS = @$(TARGET).imp +EPREFIX = LIBGD + +# Edit the var below to point to your lib architecture. +ifndef LIBARCH +LIBARCH = LIBC +endif + +# must be equal to DEBUG or NDEBUG +DB = NDEBUG +# DB = DEBUG +# Optimization: -O<n> or debugging: -g +ifeq ($(DB),NDEBUG) + OPT = -O2 + OBJDIR = release +else + OPT = -g + OBJDIR = debug +endif + +# Include the version info retrieved from xml2ver.h +-include $(OBJDIR)/version.inc + +# The following line defines your compiler. +ifdef METROWERKS + CC = mwccnlm +else + CC = gcc +endif +# http://www.gknw.net/development/prgtools/awk.zip +AWK = awk +YACC = bison -y +CP = cp -afv +# RM = rm -f +# if you want to mark the target as MTSAFE you will need a tool for +# generating the xdc data for the linker; here's a minimal tool: +# http://www.gknw.net/development/prgtools/mkxdc.zip +MPKXDC = mkxdc +PATCH = patch +PERLRUN = perl + +# Global flags for all compilers +CFLAGS = $(OPT) -D$(DB) -DNETWARE -DHAVE_CONFIG_H -nostdinc +#CFLAGS += -DHAVE_LIBPNG=1 -DHAVE_LIBJPEG=1 +#CFLAGS += -DHAVE_LIBFREETYPE=1 -DHAVE_FT2BUILD_H=1 +#CFLAGS += -DHAVE_LIBZ=1 + +ifeq ($(CC),mwccnlm) +LD = mwldnlm +LDFLAGS = -nostdlib $(PRELUDE) $(OBJL) $(LDLIBS) -o $@ -commandfile +AR = mwldnlm +ARFLAGS = -type library -w nocmdline $(OBJS) -o +LIBEXT = lib +CFLAGS += -msgstyle gcc -gccinc -inline off -opt nointrinsics -proc 586 +CFLAGS += -relax_pointers +#CFLAGS += -w on +ifeq ($(LIBARCH),LIBC) + PRELUDE = $(SDK_LIBC)/imports/libcpre.o + CFLAGS += -align 4 +else + PRELUDE = "$(METROWERKS)/Novell Support/libraries/runtime/prelude.obj" +# CFLAGS += -include "$(METROWERKS)/Novell Support/headers/nlm_prefix.h" + CFLAGS += -align 1 +endif +else +LD = nlmconv +LDFLAGS = -T +AR = ar +ARFLAGS = -cq +LIBEXT = a +CFLAGS += -fno-builtin -fpcc-struct-return -fno-strict-aliasing +CFLAGS += -Wall -Wno-unused -Wno-main # -pedantic +ifeq ($(LIBARCH),LIBC) + PRELUDE = $(SDK_LIBC)/imports/libcpre.gcc.o +else + PRELUDE = $(SDK_CLIB)/imports/clibpre.gcc.o + CFLAGS += -include $(NDKBASE)/nlmconv/genlm.h +endif +endif + +NDK_ROOT = $(NDKBASE)/ndk +SDK_CLIB = $(NDK_ROOT)/nwsdk +SDK_LIBC = $(NDK_ROOT)/libc + +INCLUDES = -I. -I$(LIBGD) -I$(LIBPNG) -I$(LIBJPEG) -I$(LIBFT2)/include -I$(ZLIBSDK) + +ifeq ($(LIBARCH),LIBC) + INCLUDES += -I$(SDK_LIBC)/include + # INCLUDES += -I$(SDK_LIBC)/include/nks + CFLAGS += -D_POSIX_SOURCE + # CFLAGS += -D__ANSIC__ +else + INCLUDES += -I$(SDK_CLIB)/include/nlm + # INCLUDES += -I$(SDK_CLIB)/include + # INCLUDES += -I$(SDK_CLIB)/include/nlm/obsolete +endif +CFLAGS += $(INCLUDES) + +ifeq ($(MTSAFE),YES) + XDCOPT = -n +endif +ifeq ($(MTSAFE),NO) + XDCOPT = -u +endif +ifdef XDCOPT + XDCDATA = $(OBJDIR)/$(TARGET).xdc +endif + +ifeq ($(findstring linux,$(OSTYPE)),linux) +DL = ' +#-include $(NDKBASE)/nlmconv/ncpfs.inc +endif + +GDLIBOBJS = \ + $(OBJDIR)/gd.o \ + $(OBJDIR)/gd_gd.o \ + $(OBJDIR)/gd_gd2.o \ + $(OBJDIR)/gd_gif_in.o \ + $(OBJDIR)/gd_gif_out.o \ + $(OBJDIR)/gd_io.o \ + $(OBJDIR)/gd_io_dp.o \ + $(OBJDIR)/gd_io_file.o \ + $(OBJDIR)/gd_io_ss.o \ + $(OBJDIR)/gd_jpeg.o \ + $(OBJDIR)/gd_png.o \ + $(OBJDIR)/gd_ss.o \ + $(OBJDIR)/gd_topal.o \ + $(OBJDIR)/gd_wbmp.o \ + $(OBJDIR)/gdcache.o \ + $(OBJDIR)/gdfontg.o \ + $(OBJDIR)/gdfontl.o \ + $(OBJDIR)/gdfontmb.o \ + $(OBJDIR)/gdfonts.o \ + $(OBJDIR)/gdfontt.o \ + $(OBJDIR)/gdft.o \ + $(OBJDIR)/gdfx.o \ + $(OBJDIR)/gdhelpers.o \ + $(OBJDIR)/gdkanji.o \ + $(OBJDIR)/gdtables.o \ + $(OBJDIR)/gdxpm.o \ + $(OBJDIR)/wbmp.o \ + $(EOLIST) +ifeq "$(wildcard $(LIBGD)/gd_security.c)" "$(LIBGD)/gd_security.c" +GDLIBOBJS += \ + $(OBJDIR)/gd_security.o \ + $(EOLIST) +endif + +PNGLIBOBJS = \ + $(OBJDIR)/png.o \ + $(OBJDIR)/pngerror.o \ + $(OBJDIR)/pngget.o \ + $(OBJDIR)/pngmem.o \ + $(OBJDIR)/pngpread.o \ + $(OBJDIR)/pngread.o \ + $(OBJDIR)/pngrio.o \ + $(OBJDIR)/pngrtran.o \ + $(OBJDIR)/pngrutil.o \ + $(OBJDIR)/pngset.o \ + $(OBJDIR)/pngtrans.o \ + $(OBJDIR)/pngwio.o \ + $(OBJDIR)/pngwrite.o \ + $(OBJDIR)/pngwtran.o \ + $(OBJDIR)/pngwutil.o \ + $(EOLIST) +ifeq "$(wildcard $(LIBPNG)/pnggccrd.c)" "$(LIBPNG)/pnggccrd.c" +PNGLIBOBJS += \ + $(OBJDIR)/pnggccrd.o \ + $(OBJDIR)/pngvcrd.o \ + $(EOLIST) +endif + +OBJ_JPG = $(OBJDIR) +JPGLIBOBJS = \ + $(OBJ_JPG)/jcapimin.o \ + $(OBJ_JPG)/jcapistd.o \ + $(OBJ_JPG)/jccoefct.o \ + $(OBJ_JPG)/jccolor.o \ + $(OBJ_JPG)/jcdctmgr.o \ + $(OBJ_JPG)/jchuff.o \ + $(OBJ_JPG)/jcinit.o \ + $(OBJ_JPG)/jcmainct.o \ + $(OBJ_JPG)/jcmarker.o \ + $(OBJ_JPG)/jcmaster.o \ + $(OBJ_JPG)/jcomapi.o \ + $(OBJ_JPG)/jcparam.o \ + $(OBJ_JPG)/jcphuff.o \ + $(OBJ_JPG)/jcprepct.o \ + $(OBJ_JPG)/jcsample.o \ + $(OBJ_JPG)/jctrans.o \ + $(OBJ_JPG)/jdapimin.o \ + $(OBJ_JPG)/jdapistd.o \ + $(OBJ_JPG)/jdatadst.o \ + $(OBJ_JPG)/jdatasrc.o \ + $(OBJ_JPG)/jdcoefct.o \ + $(OBJ_JPG)/jdcolor.o \ + $(OBJ_JPG)/jddctmgr.o \ + $(OBJ_JPG)/jdhuff.o \ + $(OBJ_JPG)/jdinput.o \ + $(OBJ_JPG)/jdmainct.o \ + $(OBJ_JPG)/jdmarker.o \ + $(OBJ_JPG)/jdmaster.o \ + $(OBJ_JPG)/jdmerge.o \ + $(OBJ_JPG)/jdphuff.o \ + $(OBJ_JPG)/jdpostct.o \ + $(OBJ_JPG)/jdsample.o \ + $(OBJ_JPG)/jdtrans.o \ + $(OBJ_JPG)/jerror.o \ + $(OBJ_JPG)/jfdctflt.o \ + $(OBJ_JPG)/jfdctfst.o \ + $(OBJ_JPG)/jfdctint.o \ + $(OBJ_JPG)/jidctflt.o \ + $(OBJ_JPG)/jidctfst.o \ + $(OBJ_JPG)/jidctint.o \ + $(OBJ_JPG)/jidctred.o \ + $(OBJ_JPG)/jquant1.o \ + $(OBJ_JPG)/jquant2.o \ + $(OBJ_JPG)/jutils.o \ + $(OBJ_JPG)/jmemmgr.o \ + $(OBJ_JPG)/jmemansi.o \ + $(EOLIST) + +LIBFT2OBJS = \ + $(OBJ_FT2)/autohint.o \ + $(OBJ_FT2)/bdf.o \ + $(OBJ_FT2)/cff.o \ + $(OBJ_FT2)/ftbase.o \ + $(OBJ_FT2)/ftcache.o \ + $(OBJ_FT2)/ftglyph.o \ + $(OBJ_FT2)/ftinit.o \ + $(OBJ_FT2)/ftmm.o \ + $(OBJ_FT2)/ftsystem.o \ + $(OBJ_FT2)/pcf.o \ + $(OBJ_FT2)/pfr.o \ + $(OBJ_FT2)/psaux.o \ + $(OBJ_FT2)/pshinter.o \ + $(OBJ_FT2)/psmodule.o \ + $(OBJ_FT2)/raster.o \ + $(OBJ_FT2)/sfnt.o \ + $(OBJ_FT2)/smooth.o \ + $(OBJ_FT2)/truetype.o \ + $(OBJ_FT2)/type1.o \ + $(OBJ_FT2)/type1cid.o \ + $(OBJ_FT2)/type42.o \ + $(OBJ_FT2)/winfnt.o \ + $(OBJ_FT2)/infutil.o \ + $(OBJ_FT2)/ftgzip.o \ + $(OBJ_FT2)/ftlzw.o \ + $(OBJ_FT2)/ftpfr.o \ + $(OBJ_FT2)/ftstroke.o \ + $(OBJ_FT2)/ftsynth.o \ + $(OBJ_FT2)/fttype1.o \ + $(OBJ_FT2)/ftwinfnt.o \ + $(OBJ_FT2)/ftxf86.o \ + $(OBJ_FT2)/ftbbox.o \ + $(EOLIST) + +ZLIBOBJS = \ + $(OBJDIR)/adler32.o \ + $(OBJDIR)/compress.o \ + $(OBJDIR)/crc32.o \ + $(OBJDIR)/deflate.o \ + $(OBJDIR)/inflate.o \ + $(OBJDIR)/inffast.o \ + $(OBJDIR)/inftrees.o \ + $(OBJDIR)/trees.o \ + $(OBJDIR)/uncompr.o \ + $(OBJDIR)/zutil.o \ + $(EOLIST) +ifeq "$(wildcard $(ZLIBSDK)/infblock.c)" "$(ZLIBSDK)/infblock.c" +ZLIBOBJS += \ + $(OBJDIR)/infblock.o \ + $(OBJDIR)/infcodes.o \ + $(OBJDIR)/infutil.o \ + $(EOLIST) +endif + +LDLIBS += $(LIBFT2)/builds/netware/LIBC/libft2.$(LIBEXT) + +OBJS := $(GDLIBOBJS) $(PNGLIBOBJS) $(JPGLIBOBJS) $(ZLIBOBJS) + +OBJL = $(OBJS) $(OBJDIR)/nwlibc.o + +vpath %.c . $(LIBGD) $(LIBPNG) $(LIBJPEG) $(ZLIBSDK) + +.PHONY: all prebuild dist install clean clean-all test-cmds help + +all: lib nlm + +nlm: prebuild $(TARGET).nlm + +lib: prebuild $(TARGET).$(LIBEXT) + +prebuild: $(OBJDIR) $(OBJDIR)/version.inc config.h + +$(OBJDIR)/%.o: %.c +# @echo Compiling $< + $(CC) $(CFLAGS) -c $< -o $@ + +$(OBJDIR)/version.inc: ../configure $(OBJDIR) + @echo Creating $@ + @$(AWK) -f get_ver.awk $< > $@ # TODO: get version info from src/gd.h + +dist: all + -$(RM) -r $(OBJDIR)* + +install: $(INSTDIR) all + @$(CP) $(TARGET).nlm $(INSTDIR) + @$(CP) $(TARGET).$(LIBEXT) $(INSTDIR) + @$(CP) ../CHANGES $(INSTDIR) + @$(CP) ../COPYING $(INSTDIR) + @$(CP) ../README $(INSTDIR) + @$(CP) ../RELEASE-NOTES $(INSTDIR) + +clean: + -$(RM) config.h + -$(RM) -r $(OBJDIR)* + -$(RM) $(TARGET).nlm $(TARGET).$(LIBEXT) $(TARGET).imp + +dist-clean: + -$(RM) config.h + -$(RM) -r $(OBJDIR)* + +clean-all: clean + -$(MAKE) -C tests -f Makefile clean + +test-cmds: + -$(MAKE) -C tests -f Makefile + +$(INSTDIR): + @mkdir $(INSTDIR) + +$(OBJDIR): + @mkdir $(OBJDIR) + +$(TARGET).$(LIBEXT): $(OBJS) + @echo Creating $@ + @-$(RM) $@ + @$(AR) $(ARFLAGS) $@ $^ + +$(TARGET).nlm: $(OBJDIR)/$(TARGET).def $(TARGET).imp $(OBJL) $(XDCDATA) + @echo Linking $@ + @-$(RM) $@ + @$(LD) $(LDFLAGS) $< + +$(OBJDIR)/%.xdc: Makefile + @echo Creating $@ + @$(MPKXDC) $(XDCOPT) $@ + +$(OBJDIR)/%.def: Makefile + @echo $(DL)# DEF file for linking with $(LD)$(DL) > $@ + @echo $(DL)# Do not edit this file - it is created by make!$(DL) >> $@ + @echo $(DL)# All your changes will be lost!!$(DL) >> $@ + @echo $(DL)#$(DL) >> $@ + @echo $(DL)copyright "$(COPYR)"$(DL) >> $@ + @echo $(DL)description "$(DESCR)"$(DL) >> $@ + @echo $(DL)version $(LIBGD_VERSION)$(DL) >> $@ +ifdef NLMTYPE + @echo $(DL)type $(NLMTYPE)$(DL) >> $@ +endif +ifdef STACK + @echo $(DL)stack $(STACK)$(DL) >> $@ +endif +ifdef SCREEN + @echo $(DL)screenname "$(SCREEN)"$(DL) >> $@ +else + @echo $(DL)screenname "DEFAULT"$(DL) >> $@ +endif +ifeq ($(DB),DEBUG) + @echo $(DL)debug$(DL) >> $@ +endif + @echo $(DL)threadname "$(TARGET)"$(DL) >> $@ +ifdef XDCDATA + @echo $(DL)xdcdata $(XDCDATA)$(DL) >> $@ +endif + @echo $(DL)flag_on 64$(DL) >> $@ +ifeq ($(LIBARCH),CLIB) + @echo $(DL)start _Prelude$(DL) >> $@ + @echo $(DL)exit _Stop$(DL) >> $@ + @echo $(DL)import @$(SDK_CLIB)/imports/clib.imp$(DL) >> $@ + @echo $(DL)import @$(SDK_CLIB)/imports/threads.imp$(DL) >> $@ + @echo $(DL)import @$(SDK_CLIB)/imports/nlmlib.imp$(DL) >> $@ + @echo $(DL)import @$(SDK_CLIB)/imports/socklib.imp$(DL) >> $@ + @echo $(DL)module clib$(DL) >> $@ +else + @echo $(DL)pseudopreemption$(DL) >> $@ + @echo $(DL)start _LibCPrelude$(DL) >> $@ + @echo $(DL)exit _LibCPostlude$(DL) >> $@ + @echo $(DL)check _LibCCheckUnload$(DL) >> $@ + @echo $(DL)import @$(SDK_LIBC)/imports/libc.imp$(DL) >> $@ + @echo $(DL)import @$(SDK_LIBC)/imports/netware.imp$(DL) >> $@ + @echo $(DL)module libc$(DL) >> $@ +endif +ifdef MODULES + @echo $(DL)module $(MODULES)$(DL) >> $@ +endif +ifdef IMPORTS + @echo $(DL)import $(IMPORTS)$(DL) >> $@ +endif +ifdef EXPORTS + @echo $(DL)export $(EXPORTS)$(DL) >> $@ +endif +ifeq ($(LD),nlmconv) + @echo $(DL)input $(OBJL)$(DL) >> $@ + @echo $(DL)input $(PRELUDE)$(DL) >> $@ +ifdef LDLIBS + @echo $(DL)input $(LDLIBS)$(DL) >> $@ +endif + @echo $(DL)output $(TARGET).nlm$(DL) >> $@ +endif + +config.h: Makefile + @echo Creating $@ + @echo $(DL)/* $@ for NetWare target.$(DL) > $@ + @echo $(DL)** Do not edit this file - it is created by make!$(DL) >> $@ + @echo $(DL)** All your changes will be lost!!$(DL) >> $@ + @echo $(DL)*/$(DL) >> $@ + @echo $(DL)#define OS "i586-pc-NetWare"$(DL) >> $@ + @echo $(DL)#define VERSION "$(LIBGD_VERSION_STR)"$(DL) >> $@ + @echo $(DL)#define PACKAGE_BUGREPORT "http://bugs.libgd.org/"$(DL) >> $@ + @echo $(DL)#define HAVE_ARPA_INET_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_ASSERT_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_DLFCN_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_DLOPEN 1$(DL) >> $@ + @echo $(DL)#define HAVE_ERR_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_ERRNO_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_FCNTL_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_FIONBIO 1$(DL) >> $@ + @echo $(DL)#define HAVE_GETHOSTBYADDR 1$(DL) >> $@ + @echo $(DL)#define HAVE_GETTIMEOFDAY 1$(DL) >> $@ + @echo $(DL)#define HAVE_INET_ADDR 1$(DL) >> $@ + @echo $(DL)#define HAVE_INET_NTOA 1$(DL) >> $@ + @echo $(DL)#define HAVE_INET_PTON 1$(DL) >> $@ + @echo $(DL)#define HAVE_INTTYPES_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_LIMITS_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_LONGLONG 1$(DL) >> $@ + @echo $(DL)#define HAVE_MALLOC_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_NETINET_IN_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_SELECT 1$(DL) >> $@ + @echo $(DL)#define HAVE_SETJMP_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_SIGNAL 1$(DL) >> $@ + @echo $(DL)#define HAVE_SOCKET 1$(DL) >> $@ + @echo $(DL)#define HAVE_STDARG_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_STDDEF_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_STDINT_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_STDLIB_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_STRCASECMP 1$(DL) >> $@ + @echo $(DL)#define HAVE_STRDUP 1$(DL) >> $@ + @echo $(DL)#define HAVE_STRFTIME 1$(DL) >> $@ + @echo $(DL)#define HAVE_STRING_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_STRLCAT 1$(DL) >> $@ + @echo $(DL)#define HAVE_STRLCPY 1$(DL) >> $@ + @echo $(DL)#define HAVE_STRSTR 1$(DL) >> $@ + @echo $(DL)#define HAVE_SYS_PARAM_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_SYS_SELECT_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_SYS_STAT_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_SYS_TIME_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_TERMIOS_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_TIME_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_UNAME 1$(DL) >> $@ + @echo $(DL)#define HAVE_UNISTD_H 1$(DL) >> $@ + @echo $(DL)#define STDC_HEADERS 1$(DL) >> $@ + @echo $(DL)#define TIME_WITH_SYS_TIME 1$(DL) >> $@ + @echo $(DL)#define HAVE_SYS_TYPES_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_ZLIB_H 1$(DL) >> $@ + @echo $(DL)#define HAVE_LIBZ 1$(DL) >> $@ + @echo $(DL)#define HAVE_LIBPNG 1$(DL) >> $@ + @echo $(DL)#define HAVE_LIBJPEG 1$(DL) >> $@ + @echo $(DL)#define HAVE_LIBFREETYPE 1$(DL) >> $@ + @echo $(DL)#define HAVE_FT2BUILD_H 1$(DL) >> $@ +# @echo $(DL)#define DEFAULT_FONTPATH "sys:/java/nwgfx/lib/x11/fonts/ttf"$(DL) >> $@ +# @echo $(DL)#define PATHSEPARATOR ";"$(DL) >> $@ + +$(TARGET).imp: get_exp.awk $(LIBGD)/gd.h + @echo Creating $@ + @$(AWK) -v EPREFIX=$(EPREFIX) -f $^ > $@ + +patch: Makefile + @echo Patching sources... + $(PATCH) -d $(LIBGD) -b -p 0 -i $(LIBGD)/netware/$(notdir $(wildcard $(LIBGD)/netware/*.diff)) + +help: + @echo $(DL)===========================================================$(DL) + @echo Novell NDK Base = $(NDKBASE) + @echo libpng Source = $(LIBPNG) + @echo libjpeg Source = $(LIBJPEG) + @echo Freetype 2 SDK = $(LIBFT2) + @echo Zlib SDK = $(ZLIBSDK) + @echo $(DL)===========================================================$(DL) + @echo $(DL)libgd $(LIBGD_VERSION_STR) - available targets are:$(DL) + @echo $(DL)$(MAKE) all$(DL) + @echo $(DL)$(MAKE) nlm$(DL) + @echo $(DL)$(MAKE) lib$(DL) + @echo $(DL)$(MAKE) clean$(DL) + @echo $(DL)$(MAKE) clean-all$(DL) + @echo $(DL)$(MAKE) test-cmds$(DL) + @echo $(DL)$(MAKE) patch$(DL) + @echo $(DL)===========================================================$(DL) + + diff --git a/Build/source/libs/gd/libgd-2.1.1/netware/get_exp.awk b/Build/source/libs/gd/libgd-2.1.1/netware/get_exp.awk new file mode 100644 index 00000000000..5428bf63ca7 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/netware/get_exp.awk @@ -0,0 +1,37 @@ +#!awk +# awk hack to fetch libgd export functions from header +# and write them to STDOUT. Here you can get an awk version for Win32: +# http://www.gknw.net/development/prgtools/awk.zip +# $Id$ +# +BEGIN { + print "# Exports extracted from " ARGV[1] ""; + print "# Do not edit this file - it is created by make!"; + print "# All your changes will be lost!!"; + if (EPREFIX) { + print " (" EPREFIX ")"; + } + print " gdFontGetGiant,"; + print " gdFontGetLarge,"; + print " gdFontGetMediumBold,"; + print " gdFontGetSmall,"; + print " gdFontGetTiny,"; + print " gdImageSquareToCircle,"; + print " gdImageStringFTCircle,"; + print " gdImageSharpen,"; +} + +# try to catch the function names from lines like: +# BGD_DECLARE(gdImagePtr) function ... +# BGD_DECLARE(void *) function ... +# +/^[ \t]*BGD_DECLARE\([^\)]*\) +(gd[A-Za-z0-9_]+)/ { + sub(/^[ \t]*BGD_DECLARE\([^\)]+\) +/, ""); + sub(/[ \t]*\(.*$/, ""); + # hack to filter gdImageEllipse() since we have no C implementation. + if ($0 != "gdImageEllipse") { + print " " $0 ","; + } +} + + diff --git a/Build/source/libs/gd/libgd-2.1.1/netware/get_ver.awk b/Build/source/libs/gd/libgd-2.1.1/netware/get_ver.awk new file mode 100644 index 00000000000..8747a338a57 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/netware/get_ver.awk @@ -0,0 +1,28 @@ +#!awk +# awk script which fetches libgd version number and string from input file +# and writes them to STDOUT. Here you can get an awk version for Win32: +# http://www.gknw.net/development/prgtools/awk.zip +# $Id$ +# +BEGIN { + while ((getline < ARGV[1]) > 0) { + if (match ($0, /^GDLIB_MAJOR=([0-9]*)$/)) { + split($1, t, "="); + v_maj = t[2]; + } + if (match ($0, /^GDLIB_MINOR=([0-9]*)$/)) { + split($1, t, "="); + v_min = t[2]; + } + if (match ($0, /^GDLIB_REVISION=([0-9]*)$/)) { + split($1, t, "="); + v_rev = t[2]; + } + } + libgd_ver = v_maj "," v_min "," v_rev; + libgd_ver_str = v_maj "." v_min "." v_rev; + print "LIBGD_VERSION = " libgd_ver ""; + print "LIBGD_VERSION_STR = " libgd_ver_str ""; +} + + diff --git a/Build/source/libs/gd/libgd-2.1.1/netware/keepscreen.c b/Build/source/libs/gd/libgd-2.1.1/netware/keepscreen.c new file mode 100644 index 00000000000..0ff85628524 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/netware/keepscreen.c @@ -0,0 +1,27 @@ +/* Simple _NonAppStop() implementation which can be linked to your + * NLM in order to keep the screen open when the NLM terminates + * (the good old clib behaviour). + * You dont have to call it, its done automatically from LibC. + * + * 2004-Aug-11 by Guenter Knauf + * + * URL: http://www.gknw.com/development/mk_nlm/ + * + * $Id$ + */ + +#include <stdio.h> +#include <screen.h> + +void _NonAppStop() +{ + uint16_t row, col; + + GetScreenSize(&row, &col); + gotorowcol(row-1, 0); + /* pressanykey(); */ + printf("<Press any key to close screen> "); + getcharacter(); +} + + diff --git a/Build/source/libs/gd/libgd-2.1.1/netware/nwlibc.c b/Build/source/libs/gd/libgd-2.1.1/netware/nwlibc.c new file mode 100644 index 00000000000..b981a554773 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/netware/nwlibc.c @@ -0,0 +1,290 @@ +/********************************************************************* + * Universal NetWare library stub. * + * written by Ulrich Neuman and given to OpenSource copyright-free. * + * version: 1.0 * + * $Id$ + *********************************************************************/ + +#include <errno.h> +#include <string.h> +#include <stdlib.h> +#include <library.h> +#include <netware.h> +#include <screen.h> +#include <nks/thread.h> +#include <nks/synch.h> + + +typedef struct { + int _errno; + void *twentybytes; +} libthreaddata_t; + +typedef struct { + int x; + int y; + int z; + void *tenbytes; + NXKey_t perthreadkey; /* if -1, no key obtained... */ + NXMutex_t *lock; +} libdata_t; + +int gLibId = -1; +void *gLibHandle = (void *) NULL; +rtag_t gAllocTag = (rtag_t) NULL; +NXMutex_t *gLibLock = (NXMutex_t *) NULL; + +/* internal library function prototypes... */ +int DisposeLibraryData ( void * ); +void DisposeThreadData ( void * ); +int GetOrSetUpData ( int id, libdata_t **data, libthreaddata_t **threaddata ); + + +int _NonAppStart +( + void *NLMHandle, + void *errorScreen, + const char *cmdLine, + const char *loadDirPath, + size_t uninitializedDataLength, + void *NLMFileHandle, + int (*readRoutineP)( int conn, void *fileHandle, size_t offset, + size_t nbytes, size_t *bytesRead, void *buffer ), + size_t customDataOffset, + size_t customDataSize, + int messageCount, + const char **messages +) +{ + NX_LOCK_INFO_ALLOC(liblock, "Per-Application Data Lock", 0); + +#ifndef __GNUC__ +#pragma unused(cmdLine) +#pragma unused(loadDirPath) +#pragma unused(uninitializedDataLength) +#pragma unused(NLMFileHandle) +#pragma unused(readRoutineP) +#pragma unused(customDataOffset) +#pragma unused(customDataSize) +#pragma unused(messageCount) +#pragma unused(messages) +#endif + + /* + ** Here we process our command line, post errors (to the error screen), + ** perform initializations and anything else we need to do before being able + ** to accept calls into us. If we succeed, we return non-zero and the NetWare + ** Loader will leave us up, otherwise we fail to load and get dumped. + */ + gAllocTag = AllocateResourceTag(NLMHandle, + "<library-name> memory allocations", AllocSignature); + + if (!gAllocTag) { + OutputToScreen(errorScreen, "Unable to allocate resource tag for " + "library memory allocations.\n"); + return -1; + } + + gLibId = register_library(DisposeLibraryData); + + if (gLibId < -1) { + OutputToScreen(errorScreen, "Unable to register library with kernel.\n"); + return -1; + } + + gLibHandle = NLMHandle; + + gLibLock = NXMutexAlloc(0, 0, &liblock); + + if (!gLibLock) { + OutputToScreen(errorScreen, "Unable to allocate library data lock.\n"); + return -1; + } + + return 0; +} + +/* +** Here we clean up any resources we allocated. Resource tags is a big part +** of what we created, but NetWare doesn't ask us to free those. +*/ +void _NonAppStop( void ) +{ + (void) unregister_library(gLibId); + NXMutexFree(gLibLock); +} + +/* +** This function cannot be the first in the file for if the file is linked +** first, then the check-unload function's offset will be nlmname.nlm+0 +** which is how to tell that there isn't one. When the check function is +** first in the linked objects, it is ambiguous. For this reason, we will +** put it inside this file after the stop function. +** +** Here we check to see if it's alright to ourselves to be unloaded. If not, +** we return a non-zero value. Right now, there isn't any reason not to allow +** it. +*/ +int _NonAppCheckUnload( void ) +{ + return 0; +} + +int GetOrSetUpData +( + int id, + libdata_t **appData, + libthreaddata_t **threadData +) +{ + int err; + libdata_t *app_data; + libthreaddata_t *thread_data; + NXKey_t key; + NX_LOCK_INFO_ALLOC(liblock, "Application Data Lock", 0); + + err = 0; + thread_data = (libthreaddata_t *) NULL; + + /* + ** Attempt to get our data for the application calling us. This is where we + ** store whatever application-specific information we need to carry in support + ** of calling applications. + */ + app_data = (libdata_t *) get_app_data(id); + + if (!app_data) { + /* + ** This application hasn't called us before; set up application AND per-thread + ** data. Of course, just in case a thread from this same application is calling + ** us simultaneously, we better lock our application data-creation mutex. We + ** also need to recheck for data after we acquire the lock because WE might be + ** that other thread that was too late to create the data and the first thread + ** in will have created it. + */ + NXLock(gLibLock); + + if (!(app_data = (libdata_t *) get_app_data(id))) { + app_data = (libdata_t *) malloc(sizeof(libdata_t)); + + if (app_data) { + memset(app_data, 0, sizeof(libdata_t)); + + app_data->tenbytes = malloc(10); + app_data->lock = NXMutexAlloc(0, 0, &liblock); + + if (!app_data->tenbytes || !app_data->lock) { + if (app_data->lock) + NXMutexFree(app_data->lock); + + free(app_data); + app_data = (libdata_t *) NULL; + err = ENOMEM; + } + + if (app_data) { + /* + ** Here we burn in the application data that we were trying to get by calling + ** get_app_data(). Next time we call the first function, we'll get this data + ** we're just now setting. We also go on here to establish the per-thread data + ** for the calling thread, something we'll have to do on each application + ** thread the first time it calls us. + */ + err = set_app_data(gLibId, app_data); + + if (err) { + free(app_data); + app_data = (libdata_t *) NULL; + err = ENOMEM; + } else { + /* create key for thread-specific data... */ + err = NXKeyCreate(DisposeThreadData, (void *) NULL, &key); + + if (err) /* (no more keys left?) */ + key = -1; + + app_data->perthreadkey = key; + } + } + } + } + + NXUnlock(gLibLock); + } + + if (app_data) { + key = app_data->perthreadkey; + + if ( key != -1 /* couldn't create a key? no thread data */ + && !(err = NXKeyGetValue(key, (void **) &thread_data)) + && !thread_data) { + /* + ** Allocate the per-thread data for the calling thread. Regardless of whether + ** there was already application data or not, this may be the first call by a + ** a new thread. The fact that we allocation 20 bytes on a pointer is not very + ** important, this just helps to demonstrate that we can have arbitrarily + ** complex per-thread data. + */ + thread_data = (libthreaddata_t *) malloc(sizeof(libthreaddata_t)); + + if (thread_data) { + thread_data->_errno = 0; + thread_data->twentybytes = malloc(20); + + if (!thread_data->twentybytes) { + free(thread_data); + thread_data = (libthreaddata_t *) NULL; + err = ENOMEM; + } + + if ((err = NXKeySetValue(key, thread_data))) { + free(thread_data->twentybytes); + free(thread_data); + thread_data = (libthreaddata_t *) NULL; + } + } + } + } + + if (appData) + *appData = app_data; + + if (threadData) + *threadData = thread_data; + + return err; +} + +int DisposeLibraryData +( + void *data +) +{ + if (data) { + void *tenbytes = ((libdata_t *) data)->tenbytes; + + if (tenbytes) + free(tenbytes); + + free(data); + } + + return 0; +} + +void DisposeThreadData +( + void *data +) +{ + if (data) { + void *twentybytes = ((libthreaddata_t *) data)->twentybytes; + + if (twentybytes) + free(twentybytes); + + free(data); + } +} + + diff --git a/Build/source/libs/gd/libgd-2.1.1/netware/tests/Makefile.netware b/Build/source/libs/gd/libgd-2.1.1/netware/tests/Makefile.netware new file mode 100644 index 00000000000..74cc234cba7 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/netware/tests/Makefile.netware @@ -0,0 +1,285 @@ +################################################################### +# +## Makefile for building libgd tests (NetWare version - gnu make) +## Use: make -f Makefile +## +## Comments to: Guenter Knauf <eflash@gmx.net> +## +## $Id$ +# +################################################################### + +# Edit the path below to point to the base of your Novell NDK. +ifndef NDKBASE +NDKBASE = c:/novell +endif + +LIBGD = ../.. + +ifndef INSTDIR +INSTDIR = ../libgd-$(LIBGD_VERSION_STR)-bin-nw +endif + +# Edit the vars below to change NLM target settings. +TARGETS = gddemo.nlm gdtest.nlm gdtestft.nlm gdtopng.nlm gdcmpgif.nlm +TARGETS += gd2time.nlm gd2togif.nlm gd2topng.nlm gd2copypal.nlm +TARGETS += gifanimtest.nlm giftogd2.nlm pngtogd2.nlm pngtogd.nlm webpng.nlm +TARGETS += annotate.nlm circletexttest.nlm fontsizetest.nlm fontwheeltest.nlm +TARGETS += testac.nlm testtr.nlm + +DTARGET = ../libgd.nlm +LTARGET = ../libgd.lib +COPYR = Copyright (C) 1996-2007 Boutell.Com, Inc. +WWW = http://www.libgd.org/ +DESCR = libgd $(LIBGD_VERSION_STR) $(subst .def,,$(notdir $@)) - $(WWW) +MTSAFE = YES +STACK = 64000 +#SCREEN = NONE +#SCREEN = $(DESCR) +# Comment the line below if you dont want to load protected automatically. +#LDRING = 3 + +# Comment the line below if you dont want to link the static libgd.lib. +#LSTATIC = 1 + +ifdef LSTATIC +LDLIBS = $(LTARGET) +else +IMPORTS = @../libgd.imp +MODULES = $(notdir $(DTARGET)) +endif + +# Edit the var below to point to your lib architecture. +ifndef LIBARCH +LIBARCH = LIBC +endif + +# must be equal to DEBUG or NDEBUG +DB = NDEBUG +# DB = DEBUG +# DB = CURLDEBUG +# Optimization: -O<n> or debugging: -g +ifeq ($(DB),NDEBUG) + OPT = -O2 + OBJDIR = release +else + OPT = -g + OBJDIR = debug +endif + +# Include the version info retrieved from header. +-include $(OBJDIR)/version.inc + +# The following line defines your compiler. +ifdef METROWERKS + CC = mwccnlm +else + CC = gcc +endif +YACC = bison -y +CP = cp -afv +# RM = rm -f +# if you want to mark the target as MTSAFE you will need a tool for +# generating the xdc data for the linker; here's a minimal tool: +# http://www.gknw.net/development/prgtools/mkxdc.zip +MPKXDC = mkxdc + +# Global flags for all compilers +CFLAGS = $(OPT) -D$(DB) -DNETWARE -DHAVE_CONFIG_H -nostdinc + +ifeq ($(CC),mwccnlm) +LD = mwldnlm +#LDFLAGS = -nostdlib $(PRELUDE) $(LDLIBS) $(<:.def=.o) -o $@ -commandfile +LDFLAGS = -nostdlib $(PRELUDE) $(OBJSCR) $(LDLIBS) $(OBJDIR)/$(basename $@).o -o $@ -commandfile +AR = mwldnlm +ARFLAGS = -type library -w nocmdline $(OBJS) -o +CFLAGS += -msgstyle gcc -gccinc -inline off -opt nointrinsics -proc 586 +CFLAGS += -relax_pointers +#CFLAGS += -w on +ifeq ($(LIBARCH),LIBC) + PRELUDE = $(SDK_LIBC)/imports/libcpre.o + CFLAGS += -align 4 +else + PRELUDE = "$(METROWERKS)/Novell Support/libraries/runtime/prelude.obj" +# CFLAGS += -include "$(METROWERKS)/Novell Support/headers/nlm_prefix.h" + CFLAGS += -align 1 +endif +else +LD = nlmconv +LDFLAGS = -T +AR = ar +ARFLAGS = -cq +CFLAGS += -fno-builtin -fpcc-struct-return -fno-strict-aliasing +CFLAGS += -Wall -Wno-unused #-Wno-format # -pedantic +ifeq ($(LIBARCH),LIBC) + PRELUDE = $(SDK_LIBC)/imports/libcpre.gcc.o +else + PRELUDE = $(SDK_CLIB)/imports/clibpre.gcc.o + CFLAGS += -include $(NDKBASE)/nlmconv/genlm.h +endif +endif + +NDK_ROOT = $(NDKBASE)/ndk +SDK_CLIB = $(NDK_ROOT)/nwsdk +SDK_LIBC = $(NDK_ROOT)/libc + +ifeq ($(LIBARCH),LIBC) + INCLUDES += -I$(SDK_LIBC)/include + # INCLUDES += -I$(SDK_LIBC)/include/nks + CFLAGS += -D_POSIX_SOURCE + # CFLAGS += -D__ANSIC__ +else + INCLUDES += -I$(SDK_CLIB)/include/nlm + # INCLUDES += -I$(SDK_CLIB)/include + # INCLUDES += -I$(SDK_CLIB)/include/nlm/obsolete +endif +CFLAGS += -I. -I.. -I$(LIBGD) +CFLAGS += $(INCLUDES) + +ifeq ($(MTSAFE),YES) + XDCOPT = -n +endif +ifeq ($(MTSAFE),NO) + XDCOPT = -u +endif + +ifeq ($(findstring linux,$(OSTYPE)),linux) +DL = ' +#-include $(NDKBASE)/nlmconv/ncpfs.inc +endif + +vpath %.c . .. $(LIBGD) + +ifdef SCREEN +ifneq ($(SCREEN),NONE) +OBJSCR = $(OBJDIR)/keepscreen.o +endif +endif + +.PHONY: all prebuild dist install clean +.PRECIOUS: $(OBJDIR)/%.o $(OBJDIR)/%.def $(OBJDIR)/%.xdc $(LTARGET) $(DTARGET) + +all: prebuild $(TARGETS) + +prebuild: $(OBJDIR) $(OBJDIR)/version.inc +ifdef LSTATIC + $(MAKE) -C ../ -f Makefile lib +else + $(MAKE) -C ../ -f Makefile nlm +endif + +dist: all + -$(RM) -r $(OBJDIR) + +install: $(INSTDIR) all + @$(CP) *.nlm $(INSTDIR) + @$(CP) ../CHANGES $(INSTDIR) + @$(CP) ../COPYING $(INSTDIR) + @$(CP) ../README $(INSTDIR) + @$(CP) ../RELEASE-NOTES $(INSTDIR) + +clean: + -$(RM) -r $(OBJDIR) + -$(RM) $(TARGETS) + +clean-all: clean + -$(MAKE) -C ../ -f Makefile clean + +%.lib: $(OBJS) + @echo Creating $@ + @-$(RM) $@ + @$(AR) $(ARFLAGS) $@ $^ + +%.nlm: $(OBJDIR)/%.def $(OBJDIR)/%.o $(OBJDIR)/%.xdc $(OBJSCR) $(LDLIBS) + @echo Linking $@ + @-$(RM) $@ + @$(LD) $(LDFLAGS) $< + +$(INSTDIR): + @mkdir $(INSTDIR) + +$(OBJDIR): + @mkdir $(OBJDIR) + +$(OBJDIR)/%.o: %.c +# @echo Compiling $< + $(CC) $(CFLAGS) -c $< -o $@ + +$(OBJDIR)/version.inc: ../../configure.ac $(OBJDIR) + @echo Creating $@ + @awk -f ../get_ver.awk $< > $@ + +$(OBJDIR)/%.xdc: Makefile + @echo Creating $@ + @$(MPKXDC) $(XDCOPT) $@ + +$(OBJDIR)/%.def: Makefile + @echo Creating $@ + @echo $(DL)# DEF file for linking with $(LD)$(DL) > $@ + @echo $(DL)# Do not edit this file - it is created by make!$(DL) >> $@ + @echo $(DL)# All your changes will be lost!!$(DL) >> $@ + @echo $(DL)#$(DL) >> $@ + @echo $(DL)copyright "$(COPYR)"$(DL) >> $@ + @echo $(DL)description "$(DESCR)"$(DL) >> $@ + @echo $(DL)version $(LIBGD_VERSION)$(DL) >> $@ +ifdef NLMTYPE + @echo $(DL)type $(NLMTYPE)$(DL) >> $@ +endif +ifdef STACK + @echo $(DL)stack $(STACK)$(DL) >> $@ +endif +ifdef SCREEN + @echo $(DL)screenname "$(SCREEN)"$(DL) >> $@ +else + @echo $(DL)screenname "DEFAULT"$(DL) >> $@ +endif +ifeq ($(DB),DEBUG) + @echo $(DL)debug$(DL) >> $@ +endif + @echo $(DL)threadname "$(subst .def,,$(notdir $@))"$(DL) >> $@ +ifdef XDCOPT + @echo $(DL)xdcdata $(@:.def=.xdc)$(DL) >> $@ +endif +ifeq ($(LDRING),0) + @echo $(DL)flag_on 16$(DL) >> $@ +endif +ifeq ($(LDRING),3) + @echo $(DL)flag_on 512$(DL) >> $@ +endif + @echo $(DL)flag_on 64$(DL) >> $@ +ifeq ($(LIBARCH),CLIB) + @echo $(DL)start _Prelude$(DL) >> $@ + @echo $(DL)exit _Stop$(DL) >> $@ + @echo $(DL)import @$(SDK_CLIB)/imports/clib.imp$(DL) >> $@ + @echo $(DL)import @$(SDK_CLIB)/imports/threads.imp$(DL) >> $@ + @echo $(DL)import @$(SDK_CLIB)/imports/nlmlib.imp$(DL) >> $@ + @echo $(DL)module clib$(DL) >> $@ +else + @echo $(DL)pseudopreemption$(DL) >> $@ + @echo $(DL)start _LibCPrelude$(DL) >> $@ + @echo $(DL)exit _LibCPostlude$(DL) >> $@ + @echo $(DL)check _LibCCheckUnload$(DL) >> $@ + @echo $(DL)import @$(SDK_LIBC)/imports/libc.imp$(DL) >> $@ + @echo $(DL)import @$(SDK_LIBC)/imports/netware.imp$(DL) >> $@ + @echo $(DL)module libc$(DL) >> $@ +endif +ifdef MODULES + @echo $(DL)module $(MODULES)$(DL) >> $@ +endif +ifdef EXPORTS + @echo $(DL)export $(EXPORTS)$(DL) >> $@ +endif +ifdef IMPORTS + @echo $(DL)import $(IMPORTS)$(DL) >> $@ +endif +ifeq ($(LD),nlmconv) + @echo $(DL)input $(PRELUDE)$(DL) >> $@ + @echo $(DL)input $(OBJSCR)$(DL) >> $@ + @echo $(DL)input $(@:.def=.o)$(DL) >> $@ +ifdef LSTATIC + @echo $(DL)input $(LTARGET)$(DL) >> $@ +endif + @echo $(DL)output $(notdir $(@:.def=.nlm))$(DL) >> $@ +endif + + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/src/CMakeLists.txt new file mode 100644 index 00000000000..e27467dba0d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/CMakeLists.txt @@ -0,0 +1,103 @@ + +SET (LIBGD_SRC_FILES + gd.c + gdfx.c + gdfx.h + gd_color.c + gd_color.h + gd_color_map.c + gd_color_map.h + gd_crop.c + gd_transform.c + gd_security.c + gdpp.cxx + gdpp.h + gd_bmp.c + bmp.h + gd_filter.c + gd_gd.c + gd_gd2.c + gd_io.c + gd_io.h + gd_io_stream.cxx + gd_io_stream.h + gd_io_dp.c + gd_interpolation.c + gd_gif_in.c + gd_gif_out.c + gd_io_file.c + gd_io_ss.c + gd_jpeg.c + gd_matrix.c + gd_nnquant.c + gd_nnquant.h + gd_png.c + gd_rotate.c + gd_tiff.c + gd_tga.c + gd_tga.h + gd_ss.c + gd_topal.c + gd_wbmp.c + gdcache.c + gdcache.h + gdfontg.c + gdfontg.h + gdfontl.c + gdfontl.h + gdfontmb.c + gdfontmb.h + gdfonts.c + gdfonts.h + gdfontt.c + gdfontt.h + gdft.c + gdhelpers.c + gdhelpers.h + gdkanji.c + gdtables.c + gdxpm.c + jisx0208.h + wbmp.c + gd.h + wbmp.h + gd_webp.c + webpimg.c + gd_xbm.c + gd_version.c +) + +add_library(${GD_LIB} ${LIBGD_SRC_FILES}) +add_library(${GD_LIB_STATIC} STATIC ${LIBGD_SRC_FILES}) + +if (WIN32 AND NOT MINGW AND NOT MSYS) + # SET_TARGET_PROPERTIES(${GD_LIB} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:msvcrt.lib") + SET_PROPERTY(TARGET ${GD_LIB_STATIC} APPEND PROPERTY COMPILE_DEFINITIONS NONDLL=1) +ENDIF(WIN32 AND NOT MINGW AND NOT MSYS) + +if(UNIX) + set_target_properties(${GD_LIB_STATIC} PROPERTIES OUTPUT_NAME ${GD_LIB}) +endif() + +if (MINGW OR MSYS) + ADD_DEFINITIONS("-mms-bitfields") + set_target_properties(${GD_LIB_STATIC} PROPERTIES OUTPUT_NAME ${GD_LIB}) +endif (MINGW OR MSYS) + +INCLUDE_DIRECTORIES(BEFORE "${PROJECT_BINARY_DIR}" "${CMAKE_BINARY_DIR}" "${GD_SOURCE_DIR}/src") + +target_link_libraries(${GD_LIB} ${ZLIB_LIBRARIES} ${FREETYPE_LIBRARIES} ${PNG_LIBRARIES} ${ICONV_LIBRARIES} ${LIQ_LIBRARIES} ${JPEG_LIBRARIES} ${TIFF_LIBRARIES} ${XPM_LIBRARIES} ${FONTCONFIG_LIBRARY} ${VPX_LIBRARIES}) +target_link_libraries(${GD_LIB_STATIC} ${ZLIB_LIBRARIES} ${FREETYPE_LIBRARIES} ${PNG_LIBRARIES} ${ICONV_LIBRARIES} ${LIQ_LIBRARIES} ${JPEG_LIBRARIES} ${TIFF_LIBRARIES} ${XPM_LIBRARIES} ${FONTCONFIG_LIBRARY} ${VPX_LIBRARIES} ) + +set(GD_PROGRAMS annotate gdparttopng gdtopng gd2copypal gd2topng pngtogd pngtogd2 webpng gd2togif gdcmpgif giftogd2) +foreach(program ${GD_PROGRAMS}) + add_executable(${program} ${program}.c) + target_link_libraries(${program} ${GD_LIB}) +endforeach(program) + +install(TARGETS ${GD_LIB} ${GD_LIB_STATIC} ${GD_PROGRAMS} + RUNTIME DESTINATION bin + LIBRARY DESTINATION lib + ARCHIVE DESTINATION lib) +install(PROGRAMS bdftogd DESTINATION bin) +install(FILES gd.h gdfx.h gd_io.h gdcache.h gdfontg.h gdfontl.h gdfontmb.h gdfonts.h gdfontt.h gd_color_map.h gd_errors.h DESTINATION include) diff --git a/Build/source/libs/gd/libgd-2.1.1/src/COPYING b/Build/source/libs/gd/libgd-2.1.1/src/COPYING new file mode 100644 index 00000000000..90ef1c867ef --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/COPYING @@ -0,0 +1,53 @@ + + Portions copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, + 2002 by Cold Spring Harbor Laboratory. Funded under Grant + P41-RR02188 by the National Institutes of Health. + + Portions copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 by + Boutell.Com, Inc. + + Portions relating to GD2 format copyright 1999, 2000, 2001, 2002 + Philip Warner. + + Portions relating to PNG copyright 1999, 2000, 2001, 2002 Greg + Roelofs. + + Portions relating to gdttf.c copyright 1999, 2000, 2001, 2002 John + Ellson (ellson@lucent.com). + + Portions relating to gdft.c copyright 2001, 2002 John Ellson + (ellson@lucent.com). + + Portions copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 + 2008 Pierre-Alain Joye (pierre@libgd.org). + + Portions relating to JPEG and to color quantization copyright 2000, + 2001, 2002, Doug Becker and copyright (C) 1994, 1995, 1996, 1997, + 1998, 1999, 2000, 2001, 2002, Thomas G. Lane. This software is + based in part on the work of the Independent JPEG Group. See the + file README-JPEG.TXT for more information. + + Portions relating to WBMP copyright 2000, 2001, 2002 Maurice + Szmurlo and Johan Van den Brande. + + Permission has been granted to copy, distribute and modify gd in + any context without fee, including a commercial application, + provided that this notice is present in user-accessible supporting + documentation. + + This does not affect your ownership of the derived work itself, and + the intent is to assure proper credit for the authors of gd, not to + interfere with your productive use of gd. If you have questions, + ask. "Derived works" includes all programs that utilize the + library. Credit must be given in user-accessible documentation. + + This software is provided "AS IS." The copyright holders disclaim + all warranties, either express or implied, including but not + limited to implied warranties of merchantability and fitness for a + particular purpose, with respect to this code and accompanying + documentation. + + Although their code does not appear in gd, the authors wish to thank + David Koblas, David Rowley, and Hutchison Avenue Software Corporation + for their prior contributions. + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/Makefile.am b/Build/source/libs/gd/libgd-2.1.1/src/Makefile.am new file mode 100644 index 00000000000..ac66c79e082 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/Makefile.am @@ -0,0 +1,58 @@ +## Process this file with automake to produce Makefile.in -*-Makefile-*- + +bin_PROGRAMS = gdcmpgif +check_PROGRAMS = gifanimtest gd_color_map_test + +if HAVE_LIBPNG +bin_PROGRAMS += gdtopng pngtogd webpng +check_PROGRAMS += circletexttest fontsizetest fontwheeltest gddemo testac +if HAVE_LIBZ +bin_PROGRAMS += gdparttopng gd2topng pngtogd2 +check_PROGRAMS += gdtest +endif +endif + +if HAVE_LIBJPEG +if !HAVE_LIBPNG +check_PROGRAMS += fontsizetest fontwheeltest +endif +endif + +if HAVE_LIBFONTCONFIG +check_PROGRAMS += fontconfigtest +endif + +if HAVE_LIBFREETYPE +bin_PROGRAMS += annotate +check_PROGRAMS += gdtestft testtr +endif + +if HAVE_LIBZ +bin_PROGRAMS += gd2copypal gd2togif giftogd2 +endif + +bin_SCRIPTS = bdftogd + +if HAVE_LIBZ +check_PROGRAMS += gd2time +endif + +EXTRA_DIST = bdftogd demoin.png entities.html entities.tcl CMakeLists.txt config.h.cmake gd_io_stream.cxx gdpp.cxx msinttypes/inttypes.h msinttypes/stdint.h + +include_HEADERS = gd.h gdfx.h gd_io.h gdcache.h gdfontg.h gdfontl.h gdfontmb.h gdfonts.h gdfontt.h entities.h gd_color_map.h gd_errors.h gdpp.h + +lib_LTLIBRARIES = libgd.la + +libgd_la_SOURCES = gd.c gd_color.c gd_color_map.c gd_transform.c gdfx.c gd_security.c gd_gd.c gd_gd2.c gd_io.c gd_io_dp.c gd_gif_in.c \ + gd_gif_out.c gd_io_file.c gd_io_ss.c gd_jpeg.c gd_png.c gd_ss.c gd_topal.c gd_wbmp.c gdcache.c gdfontg.c gdfontl.c \ + gdfontmb.c gdfonts.c gdfontt.c gdft.c gdhelpers.c gdhelpers.h gdkanji.c gdtables.c gdxpm.c jisx0208.h wbmp.c wbmp.h \ + gd_filter.c gd_nnquant.c gd_rotate.c gd_matrix.c gd_interpolation.c gd_crop.c webpimg.c webpimg.h gd_webp.c gd_tiff.c \ + gd_tga.c gd_tga.h gd_bmp.c bmp.h gd_color.h gd_nnquant.h gd_tga.h gd_intern.h gd_io_stream.h gd_xbm.c \ + gd_color_match.c gd_version.c gd_filename.c + +libgd_la_LDFLAGS = -version-info $(GDLIB_CURRENT):$(GDLIB_REVISION):$(GDLIB_AGE) -no-undefined + +libgd_la_LIBADD = $(LTLIBICONV) + +LDADD = libgd.la $(LIBICONV) + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/annotate.c b/Build/source/libs/gd/libgd-2.1.1/src/annotate.c new file mode 100644 index 00000000000..c66e3311306 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/annotate.c @@ -0,0 +1,207 @@ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "gd.h" + +/* A neat little utility which adds freetype text to + * existing JPEG images. Type annotate -h for instructions. + * Thanks to Joel Dubiner for supporting this work. -TBB + */ + +enum { left, center, right }; + +int main(int argc, char *argv[]) +{ +#ifndef HAVE_LIBFREETYPE + (void)argc; + (void)argv; + + /* 2.0.12 */ + fprintf(stderr, "annotate is not useful without freetype.\n" + "Install freetype, then './configure; make clean; make install'\n" + "the gd library again.\n" + ); + return 1; +#else + gdImagePtr im; + char *iin, *iout; + FILE *in, *out; + char s[1024]; + int bounds[8]; + int lines = 1; + int color = gdTrueColor(0, 0, 0); + char font[1024]; + int size = 12; + int align = left; + int x = 0, y = 0; + char *fontError; + + strcpy(font, "times"); + + if(argc != 3) { + fprintf(stderr, "Usage: annotate imagein.jpg imageout.jpg\n\n"); + fprintf(stderr, "Standard input should consist of\n"); + fprintf(stderr, "lines in the following formats:\n"); + fprintf(stderr, "color r g b (0-255 each) [a (0-127, 0 is opaque)]\n"); + fprintf(stderr, "font fontname\n"); + fprintf(stderr, "size pointsize\n"); + fprintf(stderr, "align (left|right|center)\n"); + fprintf(stderr, "move x y\n"); + fprintf(stderr, "text actual-output-text\n\n"); + fprintf(stderr, + "If the file 'paris.ttf' exists in /usr/share/fonts/truetype or in a\n"); + fprintf(stderr, + "location specified in the GDFONTPATH environment variable, 'font paris' is\n"); + fprintf(stderr, + "sufficient. You may also specify the full, rooted path of a font file.\n"); + exit(1); + } + + iin = argv[1]; + iout = argv[2]; + + in = fopen(iin, "rb"); + if(!in) { + fprintf(stderr, "Couldn't open %s\n", iin); + exit(2); + } + +#ifdef HAVE_LIBJPEG + im = gdImageCreateFromJpeg(in); +#else + fprintf(stderr, "No JPEG library support available.\n"); + exit(1); +#endif + + fclose(in); + + if(!im) { + fprintf(stderr, "%s did not load properly\n", iin); + exit(3); + } + + while(fgets(s, sizeof(s), stdin)) { + char *st; + char *text; + + st = strtok(s, " \t\r\n"); + if(!st) { + /* Be nice about blank lines */ + continue; + } + + if(!strcmp(st, "font")) { + char *st = strtok(0, " \t\r\n"); + if(!st) { + goto badLine; + } + + strcpy(font, st); + } else if(!strcmp(st, "align")) { + char *st = strtok(0, " \t\r\n"); + + if(!st) { + goto badLine; + } + + if(!strcmp(st, "left")) { + align = 0; + } else if(!strcmp(st, "center")) { + align = 1; + } else if(!strcmp(st, "right")) { + align = 2; + } + } else if(!strcmp(st, "size")) { + char *st = strtok(0, " \t\r\n"); + + if(!st) { + goto badLine; + } + + size = atoi(st); + } else if(!strcmp(st, "color")) { + char *st = strtok(0, "\r\n"); + int r, g, b, a = 0; + + if(!st) { + goto badLine; + } + + if(sscanf(st, "%d %d %d %d", &r, &g, &b, &a) < 3) { + fprintf(stderr, "Bad color at line %d\n", lines); + exit(2); + } + + color = gdTrueColorAlpha(r, g, b, a); + } else if(!strcmp(st, "move")) { + char *st = strtok(0, "\r\n"); + + if(!st) { + goto badLine; + } + + if(sscanf(st, "%d %d", &x, &y) != 2) { + fprintf(stderr, "Missing coordinates at line %d\n", lines); + exit(3); + } + } else if(!strcmp(st, "text")) { + int rx = x; + + text = strtok(0, "\r\n"); + if(!text) { + text = ""; + } + + gdImageStringFT(0, bounds, color, font, size, 0, x, y, text); + + switch(align) { + case left: + break; + + case center: + rx -= (bounds[2] - bounds[0]) / 2; + break; + + case right: + rx -= (bounds[2] - bounds[0]); + break; + } + + fontError = gdImageStringFT(im, 0, color, font, size, 0, rx, y, text); + if(fontError) { + fprintf(stderr, "font error at line %d: %s\n", lines, fontError); + exit(7); + } + + y -= (bounds[7] - bounds[1]); + } else { + goto badLine; + } + + lines++; + continue; + +badLine: + fprintf(stderr, "Bad syntax, line %d\n", lines); + exit(4); + } + + out = fopen(iout, "wb"); + if(!out) { + fprintf(stderr, "Cannot create %s\n", iout); + exit(5); + } +#ifdef HAVE_LIBJPEG + gdImageJpeg(im, out, 95); +#else + fprintf(stderr, "No JPEG library support available.\n"); +#endif + gdImageDestroy(im); + fclose(out); + return 0; +#endif /* HAVE_LIBFREETYPE */ +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/bdftogd b/Build/source/libs/gd/libgd-2.1.1/src/bdftogd new file mode 100755 index 00000000000..66ffcc9ae88 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/bdftogd @@ -0,0 +1,205 @@ +#!/usr/bin/perl -w + +# +# Simple convertor from bdf to gd font format. +# +# Author: Jan Pazdziora, adelton@fi.muni.cz, http://www.fi.muni.cz/~adelton/ +# at Faculty of Informatics, Masaryk University in Brno, Czech Republic. +# +# Example of use: +# fstobdf -s fontserverhost:7100 -fn 8x16 | ./bdftogd FontLarge gdfontl +# + +use strict; + +my $VERSION = '0.60'; +my $now = localtime; + +if (@ARGV != 2) + { die "usage: bdftogd fontname filename, eg. bdftogd FontLarge gdfontl\n"; } + +my $gdname = shift; +$gdname = 'gd' . $gdname unless $gdname =~ /^gd/i; + +my $filename = shift; +$filename = 'gd' . $filename unless $filename =~ /^gd/i; + +if (-f "$filename.c") { die "File $filename.c already exists, won't overwrite\n"; } +if (-f "$filename.h") { die "File $filename.h already exists, won't overwrite\n"; } + +my ($width, $height); +my (@data, @left, @bottom); +my ($globalleft, $globaltop); + +my ($minchar, $maxchar); + +my ($copyright, $fontdef); + +my $currentchar; +my $gobitmap = 0; + + +while (<>) + { + chomp; + s/\r$//; + my ($tag, $value) = split / /, $_, 2; + die "Font is not fixed width\n" + if $tag eq 'SPACING' and not $value =~ /[CM]/i; + + $currentchar = $value if $tag eq 'ENCODING'; + $minchar = $currentchar if not defined $minchar + or $currentchar < $minchar; + $maxchar = $currentchar if not defined $maxchar + or $currentchar > $maxchar; + + if ($tag eq 'ENDCHAR') + { + $gobitmap = 0; + my $bottom = $globaltop - $bottom[$currentchar]; + + + if ($bottom > 0) + { $data[$currentchar] = substr $data[$currentchar], 0, length($data[$currentchar]) - $bottom * $width; } + else + { $data[$currentchar] .= '0' x (-$bottom * $width); } + } + + if ($tag eq 'FONTBOUNDINGBOX') + { + my ($tag, $wid, $hei, $left, $top) = split / /; + if (defined $top) + { + $globalleft = $left; + $globaltop = $top; + $height = $hei; + $width = $wid; + } + } + if ($tag eq 'FONT' and not defined $fontdef) + { $fontdef = $value; } + if ($tag eq 'COPYRIGHT' and not defined $copyright) + { $copyright = $value; } + + if ($tag eq 'BBX') + { + my ($tag, $wid, $hei, $left, $bottom) = split / /; + if (defined $bottom) + { + $left[$currentchar] = $left; + $bottom[$currentchar] = $bottom; + } + } + + if ($gobitmap) + { + my $value = pack 'H*', $_; + my $bits = unpack 'B*', $value; + $bits = ('0' x $left[$currentchar]) . $bits; + $bits .= '0' x ($width - length $bits); + $bits = substr $bits, 0, $width; + $data[$currentchar] .= $bits; + } + + if ($tag eq 'BITMAP') + { + $gobitmap = 1; + $data[$currentchar] = ''; + } + } + +my $info = <<"EOF"; +/* + This is a header file for gd font, generated using + bdftogd version $VERSION by Jan Pazdziora, adelton\@fi.muni.cz + from bdf font + $fontdef + at $now. +EOF + +if (defined $copyright) + { + $info .= <<"EOF"; + The original bdf was holding following copyright: + $copyright + */ +EOF + } +else + { + $info .= <<"EOF"; + No copyright info was found in the original bdf. + */ +EOF + } + +open FILEC, "> $filename.c" or die "Error writing $filename.c: $!\n"; +open FILEH, "> $filename.h" or die "Error writing $filename.h: $!\n"; +print FILEC <<"EOF"; + +$info + +#include "$filename.h" + +char ${gdname}Data[] = { +EOF + +$minchar = 0 unless defined $minchar; +$maxchar = 255 unless defined $maxchar; +for (my $i = $minchar; $i <= $maxchar; $i++) + { + $data[$i] = '' unless defined $data[$i]; + $data[$i] = '0' x ($width * $height - length $data[$i]) . $data[$i]; + + print FILEC "/* Char $i */\n"; + for my $line (0 .. $height - 1) + { print FILEC join ',', split(//, substr($data[$i], $line * $width, $width)), "\n"; } + + print FILEC "\n"; + + next; + + for my $line (0 .. $height - 1) + { print substr($data[$i], $line * $width, $width), "\n"; } + } + +my $capdef = "\U_${filename}_H_"; + +print FILEC <<"EOF"; + +}; + +gdFont ${gdname}Rep = { + @{[ $maxchar - $minchar + 1]}, + $minchar, + $width, + $height, + ${gdname}Data +}; + +gdFontPtr ${gdname} = &${gdname}Rep; + +/* This file has not been truncated. */ + +EOF + + +close FILEC; + +print FILEH <<"EOF"; + +#ifndef $capdef +#define $capdef 1 + +$info + +#include "gd.h" + +extern gdFontPtr $gdname; + +#endif + +EOF + +1; + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/bmp.h b/Build/source/libs/gd/libgd-2.1.1/src/bmp.h new file mode 100644 index 00000000000..cecde0383f5 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/bmp.h @@ -0,0 +1,112 @@ +/* $Id$ */ +#ifdef __cplusplus +extern "C" { +#endif + + /* + gd_bmp.c + + Bitmap format support for libgd + + * Written 2007, Scott MacVicar + --------------------------------------------------------------------------- + + Todo: + + RLE4, RLE8 and Bitfield encoding + Add full support for Windows v4 and Windows v5 header formats + + ---------------------------------------------------------------------------- + */ + +#ifndef BMP_H +#define BMP_H 1 + +#define BMP_PALETTE_3 1 +#define BMP_PALETTE_4 2 + +#define BMP_WINDOWS_V3 40 +#define BMP_OS2_V1 12 +#define BMP_OS2_V2 64 +#define BMP_WINDOWS_V4 108 +#define BMP_WINDOWS_V5 124 + +#define BMP_BI_RGB 0 +#define BMP_BI_RLE8 1 +#define BMP_BI_RLE4 2 +#define BMP_BI_BITFIELDS 3 +#define BMP_BI_JPEG 4 +#define BMP_BI_PNG 5 + +#define BMP_RLE_COMMAND 0 +#define BMP_RLE_ENDOFLINE 0 +#define BMP_RLE_ENDOFBITMAP 1 +#define BMP_RLE_DELTA 2 + +#define BMP_RLE_TYPE_RAW 0 +#define BMP_RLE_TYPE_RLE 1 + + /* BMP header. */ + typedef struct { + /* 16 bit - header identifying the type */ + signed short int magic; + + /* 32bit - size of the file */ + int size; + + /* 16bit - these two are in the spec but "reserved" */ + signed short int reserved1; + signed short int reserved2; + + /* 32 bit - offset of the bitmap header from data in bytes */ + signed int off; + + } bmp_hdr_t; + + /* BMP info. */ + typedef struct { + /* 16bit - Type, ie Windows or OS/2 for the palette info */ + signed short int type; + /* 32bit - The length of the bitmap information header in bytes. */ + signed int len; + + /* 32bit - The width of the bitmap in pixels. */ + signed int width; + + /* 32bit - The height of the bitmap in pixels. */ + signed int height; + + /* 8 bit - The bitmap data is specified in top-down order. */ + signed char topdown; + + /* 16 bit - The number of planes. This must be set to a value of one. */ + signed short int numplanes; + + /* 16 bit - The number of bits per pixel. */ + signed short int depth; + + /* 32bit - The type of compression used. */ + signed int enctype; + + /* 32bit - The size of the image in bytes. */ + signed int size; + + /* 32bit - The horizontal resolution in pixels/metre. */ + signed int hres; + + /* 32bit - The vertical resolution in pixels/metre. */ + signed int vres; + + /* 32bit - The number of color indices used by the bitmap. */ + signed int numcolors; + + /* 32bit - The number of color indices important for displaying the bitmap. */ + signed int mincolors; + + } bmp_info_t; + +#endif + +#ifdef __cplusplus +} +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/circletexttest.c b/Build/source/libs/gd/libgd-2.1.1/src/circletexttest.c new file mode 100644 index 00000000000..55e0970c1a3 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/circletexttest.c @@ -0,0 +1,63 @@ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <stdio.h> +#include "gd.h" + +int main(void) +{ + /* 2.0.22: can't depend on PNG either */ +#ifndef HAVE_LIBPNG + fprintf(stderr, "Requires PNG support, gd was compiled without it\n"); + return 0; +#else + char *error; + FILE *in = 0; + FILE *out; + gdImagePtr im; + int radius; + /* Create an image of text on a circle, with an + * alpha channel so that we can copy it onto a + * background + * TBB: 2.0.18: shouldn't depend on JPEG + */ +#ifdef HAVE_LIBJPEG + in = fopen("eleanor.jpg", "rb"); + if(!in) { + im = gdImageCreateTrueColor(300, 300); + } else { + im = gdImageCreateFromJpeg(in); + fclose(in); + } +#else + im = gdImageCreateTrueColor(300, 300); +#endif /* HAVE_LIBJPEG */ + if(gdImageSX(im) < gdImageSY(im)) { + radius = gdImageSX(im) / 2; + } else { + radius = gdImageSY(im) / 2; + } + + error = gdImageStringFTCircle(im, + gdImageSX(im) / 2, gdImageSY(im) / 2, + radius, radius / 2, + 0.8, "arial", 24, "top text", "bottom text", + gdTrueColorAlpha(192, 100, 255, 32) + ); + if(error) { + fprintf(stderr, "gdImageStringFTEx error: %s\n", error); + } + + out = fopen("gdfx.png", "wb"); + if(!out) { + fprintf(stderr, "Can't create gdfx.png\n"); + return 1; + } + + gdImagePng(im, out); + fclose(out); + gdImageDestroy(im); +#endif /* HAVE_LIBPNG */ + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/config.h.cmake b/Build/source/libs/gd/libgd-2.1.1/src/config.h.cmake new file mode 100644 index 00000000000..a8e6f00b64d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/config.h.cmake @@ -0,0 +1,127 @@ +/* config.hin. Generated from config.h.cmake by cmake */ + +/* Define to 1 if you have the <dlfcn.h> header file. */ +#cmakedefine HAVE_DLFCN_H + +/* Define to 1 if you have the <errno.h> header file. */ +#cmakedefine HAVE_ERRNO_H + +/* Define to 1 if you have the <ft2build.h> header file. */ +#cmakedefine HAVE_FT2BUILD_H + +/* Define if you have the iconv() function. */ +#cmakedefine HAVE_ICONV + +/* Define to 1 if you have the <iconv.h> header file. */ +#cmakedefine HAVE_ICONV_H + +/* Define if <iconv.h> defines iconv_t. */ +#cmakedefine HAVE_ICONV_T_DEF + +/* Define to 1 if you have the <inttypes.h> header file. */ +#cmakedefine HAVE_INTTYPES_H + +/* Define if you have the fontconfig library. */ +#cmakedefine HAVE_LIBFONTCONFIG + +/* Define if you have the freetype library. */ +#cmakedefine HAVE_LIBFREETYPE + +/* Define if you have the jpeg library. */ +#cmakedefine HAVE_LIBJPEG + +/* Define if you have the jpeg library. */ +#cmakedefine HAVE_LIBTIFF + +/* Define to 1 if you have the `m' library (-lm). */ +#cmakedefine HAVE_LIBM + +/* Define if you have the png library. */ +#cmakedefine HAVE_LIBPNG + +/* Define if you have the VPX library. */ +#cmakedefine HAVE_LIBVPX + +/* Define to 1 if you have the <libimagequant.h> header file. */ +#cmakedefine HAVE_LIBIMAGEQUANT_H + +/* Define if you have the Xpm library. */ +#cmakedefine HAVE_LIBXPM + +/* Define if you have zlib. */ +#cmakedefine HAVE_LIBZ + +/* Define to 1 if you have the <limits.h> header file. */ +#cmakedefine HAVE_LIMITS_H + +/* Define to 1 if you have the <memory.h> header file. */ +#cmakedefine HAVE_MEMORY_H + +/* Define to 1 if you have the <png.h> header file. */ +#cmakedefine HAVE_PNG_H + +/* Define if you have POSIX threads libraries and header files. */ +#cmakedefine HAVE_PTHREAD + +/* Define to 1 if you have the <stddef.h> header file. */ +#cmakedefine HAVE_STDDEF_H + +/* Define to 1 if you have the <stdint.h> header file. */ +#cmakedefine HAVE_STDINT_H + +/* Define to 1 if you have the <stdlib.h> header file. */ +#cmakedefine HAVE_STDLIB_H + +/* Define to 1 if you have the <strings.h> header file. */ +#cmakedefine HAVE_STRINGS_H + +/* Define to 1 if you have the <string.h> header file. */ +#cmakedefine HAVE_STRING_H + +/* Define to 1 if you have the <sys/stat.h> header file. */ +#cmakedefine HAVE_SYS_STAT_H + +/* Define to 1 if you have the <sys/types.h> header file. */ +#cmakedefine HAVE_SYS_TYPES_H + +/* Define to 1 if you have the <unistd.h> header file. */ +#ifndef HAVE_UNISTD_H +#cmakedefine HAVE_UNISTD_H +#endif + +/* Define as const if the declaration of iconv() needs const. */ +#cmakedefine ICONV_CONST + +/* Name of package */ +#cmakedefine PACKAGE + +/* Define to the address where bug reports for this package should be sent. */ +#cmakedefine PACKAGE_BUGREPORT + +/* Define to the full name of this package. */ +#cmakedefine PACKAGE_NAME + +/* Define to the full name and version of this package. */ +#cmakedefine PACKAGE_STRING + +/* Define to the one symbol short name of this package. */ +#cmakedefine PACKAGE_TARNAME + +/* Define to the version of this package. */ +#cmakedefine PACKAGE_VERSION + +/* Define to necessary symbol if this constant uses a non-standard name on + your system. */ +#cmakedefine PTHREAD_CREATE_JOINABLE + +/* Define to 1 if you have the ANSI C header files. */ +#cmakedefine STDC_HEADERS + +/* Define to 1 if you have the stdint.h header file. */ +#cmakedefine HAVE_STDINT_H + +/* Define to 1 if you have the inttypes.h header file. */ +#cmakedefine HAVE_INTTYPES_H + +/* Version number of package */ + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/config.hin b/Build/source/libs/gd/libgd-2.1.1/src/config.hin new file mode 100644 index 00000000000..54aeb524284 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/config.hin @@ -0,0 +1,133 @@ +/* src/config.hin. Generated from configure.ac by autoheader. */ + +/* Define is you are building for Win32 API */ +#undef BGDWIN32 + +/* Define to 1 if you have the <dlfcn.h> header file. */ +#undef HAVE_DLFCN_H + +/* Define to 1 if you have the <errno.h> header file. */ +#undef HAVE_ERRNO_H + +/* Define if you have the ft2build.h header. */ +#undef HAVE_FT2BUILD_H + +/* Define if you have the iconv() function and it works. */ +#undef HAVE_ICONV + +/* Define to 1 if you have the <iconv.h> header file. */ +#undef HAVE_ICONV_H + +/* Define if <iconv.h> defines iconv_t. */ +#undef HAVE_ICONV_T_DEF + +/* Define to 1 if you have the <inttypes.h> header file. */ +#undef HAVE_INTTYPES_H + +/* Define if you have the fontconfig library. */ +#undef HAVE_LIBFONTCONFIG + +/* Define if you have the freetype library. */ +#undef HAVE_LIBFREETYPE + +/* Define if you have the jpeg library. */ +#undef HAVE_LIBJPEG + +/* Define to 1 if you have the `m' library (-lm). */ +#undef HAVE_LIBM + +/* Define if you have the png library. */ +#undef HAVE_LIBPNG + +/* Define if you have the Tiff library. */ +#undef HAVE_LIBTIFF + +/* Define if you have the VPX library. */ +#undef HAVE_LIBVPX + +/* Define if you have the Xpm library. */ +#undef HAVE_LIBXPM + +/* Define if you have zlib. */ +#undef HAVE_LIBZ + +/* Define to 1 if you have the <limits.h> header file. */ +#undef HAVE_LIMITS_H + +/* Define to 1 if you have the <memory.h> header file. */ +#undef HAVE_MEMORY_H + +/* Define if you have POSIX threads libraries and header files. */ +#undef HAVE_PTHREAD + +/* Have PTHREAD_PRIO_INHERIT. */ +#undef HAVE_PTHREAD_PRIO_INHERIT + +/* Define to 1 if you have the <stddef.h> header file. */ +#undef HAVE_STDDEF_H + +/* Define to 1 if you have the <stdint.h> header file. */ +#undef HAVE_STDINT_H + +/* Define to 1 if you have the <stdlib.h> header file. */ +#undef HAVE_STDLIB_H + +/* Define to 1 if you have the <strings.h> header file. */ +#undef HAVE_STRINGS_H + +/* Define to 1 if you have the <string.h> header file. */ +#undef HAVE_STRING_H + +/* Define to 1 if you have the <sys/stat.h> header file. */ +#undef HAVE_SYS_STAT_H + +/* Define to 1 if you have the <sys/types.h> header file. */ +#undef HAVE_SYS_TYPES_H + +/* Define to 1 if you have the <unistd.h> header file. */ +#undef HAVE_UNISTD_H + +/* Define to 1 or 0, depending whether the compiler supports simple visibility + declarations. */ +#undef HAVE_VISIBILITY + +/* Define as const if the declaration of iconv() needs const. */ +#undef ICONV_CONST + +/* Define to the sub-directory in which libtool stores uninstalled libraries. + */ +#undef LT_OBJDIR + +/* Define to 1 if your C compiler doesn't accept -c and -o together. */ +#undef NO_MINUS_C_MINUS_O + +/* Name of package */ +#undef PACKAGE + +/* Define to the address where bug reports for this package should be sent. */ +#undef PACKAGE_BUGREPORT + +/* Define to the full name of this package. */ +#undef PACKAGE_NAME + +/* Define to the full name and version of this package. */ +#undef PACKAGE_STRING + +/* Define to the one symbol short name of this package. */ +#undef PACKAGE_TARNAME + +/* Define to the home page for this package. */ +#undef PACKAGE_URL + +/* Define to the version of this package. */ +#undef PACKAGE_VERSION + +/* Define to necessary symbol if this constant uses a non-standard name on + your system. */ +#undef PTHREAD_CREATE_JOINABLE + +/* Define to 1 if you have the ANSI C header files. */ +#undef STDC_HEADERS + +/* Version number of package */ +#undef VERSION diff --git a/Build/source/libs/gd/libgd-2.1.1/src/demoin.png b/Build/source/libs/gd/libgd-2.1.1/src/demoin.png Binary files differnew file mode 100644 index 00000000000..c3e57b2081e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/demoin.png diff --git a/Build/source/libs/gd/libgd-2.1.1/src/entities.h b/Build/source/libs/gd/libgd-2.1.1/src/entities.h new file mode 100644 index 00000000000..cf24cb63e3d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/entities.h @@ -0,0 +1,277 @@ +/* + * Generated file - do not edit directly. + * + * This file was generated from: + * http://www.w3.org/TR/REC-html40/sgml/entities.html + * by means of the script: + * entities.tcl + */ + +#ifdef __cplusplus +extern "C" { +#endif + + static struct entities_s { + char *name; + int value; + } entities[] = { + {"AElig", 198}, + {"Aacute", 193}, + {"Acirc", 194}, + {"Agrave", 192}, + {"Alpha", 913}, + {"Aring", 197}, + {"Atilde", 195}, + {"Auml", 196}, + {"Beta", 914}, + {"Ccedil", 199}, + {"Chi", 935}, + {"Dagger", 8225}, + {"Delta", 916}, + {"ETH", 208}, + {"Eacute", 201}, + {"Ecirc", 202}, + {"Egrave", 200}, + {"Epsilon", 917}, + {"Eta", 919}, + {"Euml", 203}, + {"Gamma", 915}, + {"Iacute", 205}, + {"Icirc", 206}, + {"Igrave", 204}, + {"Iota", 921}, + {"Iuml", 207}, + {"Kappa", 922}, + {"Lambda", 923}, + {"Mu", 924}, + {"Ntilde", 209}, + {"Nu", 925}, + {"OElig", 338}, + {"Oacute", 211}, + {"Ocirc", 212}, + {"Ograve", 210}, + {"Omega", 937}, + {"Omicron", 927}, + {"Oslash", 216}, + {"Otilde", 213}, + {"Ouml", 214}, + {"Phi", 934}, + {"Pi", 928}, + {"Prime", 8243}, + {"Psi", 936}, + {"Rho", 929}, + {"Scaron", 352}, + {"Sigma", 931}, + {"THORN", 222}, + {"Tau", 932}, + {"Theta", 920}, + {"Uacute", 218}, + {"Ucirc", 219}, + {"Ugrave", 217}, + {"Upsilon", 933}, + {"Uuml", 220}, + {"Xi", 926}, + {"Yacute", 221}, + {"Yuml", 376}, + {"Zeta", 918}, + {"aacute", 225}, + {"acirc", 226}, + {"acute", 180}, + {"aelig", 230}, + {"agrave", 224}, + {"alefsym", 8501}, + {"alpha", 945}, + {"amp", 38}, + {"and", 8743}, + {"ang", 8736}, + {"aring", 229}, + {"asymp", 8776}, + {"atilde", 227}, + {"auml", 228}, + {"bdquo", 8222}, + {"beta", 946}, + {"brvbar", 166}, + {"bull", 8226}, + {"cap", 8745}, + {"ccedil", 231}, + {"cedil", 184}, + {"cent", 162}, + {"chi", 967}, + {"circ", 710}, + {"clubs", 9827}, + {"cong", 8773}, + {"copy", 169}, + {"crarr", 8629}, + {"cup", 8746}, + {"curren", 164}, + {"dArr", 8659}, + {"dagger", 8224}, + {"darr", 8595}, + {"deg", 176}, + {"delta", 948}, + {"diams", 9830}, + {"divide", 247}, + {"eacute", 233}, + {"ecirc", 234}, + {"egrave", 232}, + {"empty", 8709}, + {"emsp", 8195}, + {"ensp", 8194}, + {"epsilon", 949}, + {"equiv", 8801}, + {"eta", 951}, + {"eth", 240}, + {"euml", 235}, + {"euro", 8364}, + {"exist", 8707}, + {"fnof", 402}, + {"forall", 8704}, + {"frac12", 189}, + {"frac14", 188}, + {"frac34", 190}, + {"frasl", 8260}, + {"gamma", 947}, + {"ge", 8805}, + {"gt", 62}, + {"hArr", 8660}, + {"harr", 8596}, + {"hearts", 9829}, + {"hellip", 8230}, + {"iacute", 237}, + {"icirc", 238}, + {"iexcl", 161}, + {"igrave", 236}, + {"image", 8465}, + {"infin", 8734}, + {"int", 8747}, + {"iota", 953}, + {"iquest", 191}, + {"isin", 8712}, + {"iuml", 239}, + {"kappa", 954}, + {"lArr", 8656}, + {"lambda", 955}, + {"lang", 9001}, + {"laquo", 171}, + {"larr", 8592}, + {"lceil", 8968}, + {"ldquo", 8220}, + {"le", 8804}, + {"lfloor", 8970}, + {"lowast", 8727}, + {"loz", 9674}, + {"lrm", 8206}, + {"lsaquo", 8249}, + {"lsquo", 8216}, + {"lt", 60}, + {"macr", 175}, + {"mdash", 8212}, + {"micro", 181}, + {"middot", 183}, + {"minus", 8722}, + {"mu", 956}, + {"nabla", 8711}, + {"nbsp", 160}, + {"ndash", 8211}, + {"ne", 8800}, + {"ni", 8715}, + {"not", 172}, + {"notin", 8713}, + {"nsub", 8836}, + {"ntilde", 241}, + {"nu", 957}, + {"oacute", 243}, + {"ocirc", 244}, + {"oelig", 339}, + {"ograve", 242}, + {"oline", 8254}, + {"omega", 969}, + {"omicron", 959}, + {"oplus", 8853}, + {"or", 8744}, + {"ordf", 170}, + {"ordm", 186}, + {"oslash", 248}, + {"otilde", 245}, + {"otimes", 8855}, + {"ouml", 246}, + {"para", 182}, + {"part", 8706}, + {"permil", 8240}, + {"perp", 8869}, + {"phi", 966}, + {"pi", 960}, + {"piv", 982}, + {"plusmn", 177}, + {"pound", 163}, + {"prime", 8242}, + {"prod", 8719}, + {"prop", 8733}, + {"psi", 968}, + {"quot", 34}, + {"rArr", 8658}, + {"radic", 8730}, + {"rang", 9002}, + {"raquo", 187}, + {"rarr", 8594}, + {"rceil", 8969}, + {"rdquo", 8221}, + {"real", 8476}, + {"reg", 174}, + {"rfloor", 8971}, + {"rho", 961}, + {"rlm", 8207}, + {"rsaquo", 8250}, + {"rsquo", 8217}, + {"sbquo", 8218}, + {"scaron", 353}, + {"sdot", 8901}, + {"sect", 167}, + {"shy", 173}, + {"sigma", 963}, + {"sigmaf", 962}, + {"sim", 8764}, + {"spades", 9824}, + {"sub", 8834}, + {"sube", 8838}, + {"sum", 8721}, + {"sup", 8835}, + {"sup1", 185}, + {"sup2", 178}, + {"sup3", 179}, + {"supe", 8839}, + {"szlig", 223}, + {"tau", 964}, + {"there4", 8756}, + {"theta", 952}, + {"thetasym", 977}, + {"thinsp", 8201}, + {"thorn", 254}, + {"tilde", 732}, + {"times", 215}, + {"trade", 8482}, + {"uArr", 8657}, + {"uacute", 250}, + {"uarr", 8593}, + {"ucirc", 251}, + {"ugrave", 249}, + {"uml", 168}, + {"upsih", 978}, + {"upsilon", 965}, + {"uuml", 252}, + {"weierp", 8472}, + {"xi", 958}, + {"yacute", 253}, + {"yen", 165}, + {"yuml", 255}, + {"zeta", 950}, + {"zwj", 8205}, + {"zwnj", 8204}, + }; + +#define ENTITY_NAME_LENGTH_MAX 8 +#define NR_OF_ENTITIES 252 + +#ifdef __cplusplus +} +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/entities.html b/Build/source/libs/gd/libgd-2.1.1/src/entities.html new file mode 100644 index 00000000000..5c5d7b65a32 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/entities.html @@ -0,0 +1,682 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> +<html lang="en"><head> +<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>Character entity references in HTML 4</title> + +<link rel="previous" href="http://www.w3.org/TR/REC-html40/sgml/framesetdtd.html"> +<link rel="next" href="http://www.w3.org/TR/REC-html40/appendix/changes.html"> +<link rel="contents" href="http://www.w3.org/TR/REC-html40/cover.html#toc"> +<link rel="stylesheet" type="text/css" href="entities.html_files/W3C-REC.css"> +<link rel="STYLESHEET" href="entities.html_files/default.css" type="text/css"></head> + +<body> +<div class="navbar" align="center"> <a href="http://www.w3.org/TR/REC-html40/sgml/framesetdtd.html"> +previous</a> <a href="http://www.w3.org/TR/REC-html40/appendix/changes.html">next</a> <a href="http://www.w3.org/TR/REC-html40/cover.html#minitoc">contents</a> <a href="http://www.w3.org/TR/REC-html40/index/elements.html"> +elements</a> <a href="http://www.w3.org/TR/REC-html40/index/attributes.html">attributes</a> <a href="http://www.w3.org/TR/REC-html40/index/list.html">index</a> + +<hr></div> + +<h1 align="center"><a name="h-24">24</a> <a name="entities">Character entity +references in HTML 4</a></h1> + +<div class="subtoc"> +<p><strong>Contents</strong></p> + +<ol> +<li><a class="tocxref" href="#h-24.1">Introduction to character entity +references</a></li> + +<li><a class="tocxref" href="#h-24.2">Character entity references for ISO +8859-1 characters</a> + +<ol> +<li><a class="tocxref" href="#h-24.2.1">The list of characters</a></li> +</ol> +</li> + +<li><a class="tocxref" href="#h-24.3">Character entity references for symbols, +mathematical symbols, and Greek letters</a> + +<ol> +<li><a class="tocxref" href="#h-24.3.1">The list of characters</a></li> +</ol> +</li> + +<li><a class="tocxref" href="#h-24.4">Character entity references for +markup-significant and internationalization characters</a> + +<ol> +<li><a class="tocxref" href="#h-24.4.1">The list of characters</a></li> +</ol> +</li> +</ol> +</div> + +<h2><a name="h-24.1">24.1</a> Introduction to character entity references</h2> + +A <a href="http://www.w3.org/TR/REC-html40/charset.html#entities">character entity reference</a> is an SGML +construct that references a character of the <a href="http://www.w3.org/TR/REC-html40/charset.html">document +character set.</a> + +<p>This version of HTML supports several sets of character entity +references:</p> + +<ul> +<li><a href="#iso-88591">ISO 8859-1 (Latin-1) characters</a> In accordance with +section 14 of <a rel="biblioentry" href="http://www.w3.org/TR/REC-html40/references.html#ref-RFC1866" class="informref">[RFC1866]</a>, the set of Latin-1 entities has been extended by +this specification to cover the whole right part of ISO-8859-1 (all code +positions with the high-order bit set), including the already commonly used +&nbsp;, &copy; and &reg;. The names of the entities are taken from +the appendices of SGML (defined in <a rel="biblioentry" href="http://www.w3.org/TR/REC-html40/references.html#ref-ISO8879" class="normref">[ISO8879]</a>).</li> + +<li><a href="#sym">symbols, mathematical symbols, and Greek letters</a>. These +characters may be represented by glyphs in the Adobe font "Symbol".</li> + +<li><a href="#misc">markup-significant and internationalization characters</a> +(e.g., for bidirectional text).</li> +</ul> + +<p>The following sections present the complete lists of character entity +references. Although, by convention, <a rel="biblioentry" href="http://www.w3.org/TR/REC-html40/references.html#ref-ISO10646" class="normref">[ISO10646]</a> the comments +following each entry are usually written with uppercase letters, we have +converted them to lowercase in this specification for reasons of +readability.</p> + +<h2><a name="h-24.2">24.2</a> <a name="iso-88591">Character entity references +for ISO 8859-1 characters</a></h2> + +<p>The character entity references in this section produce characters whose +numeric equivalents should already be supported by conforming HTML 2.0 user +agents. Thus, the character entity reference &divide; is a more convenient +form than &#247; for obtaining the division sign (÷).</p> + +<p>To support these named entities, user agents need only recognize the entity +names and convert them to characters that lie within the repertoire of <a rel="biblioentry" href="http://www.w3.org/TR/REC-html40/references.html#ref-ISO88591" class="normref"> +[ISO88591]</a>.</p> + +<p>Character 65533 (FFFD hexadecimal) is the last valid character in UCS-2. +65534 (FFFE hexadecimal) is unassigned and reserved as the byte-swapped version +of ZERO WIDTH NON-BREAKING SPACE for byte-order detection purposes. 65535 (FFFF +hexadecimal) is unassigned.</p> + +<h3><a name="h-24.2.1">24.2.1</a> The list of characters</h3> + +<div class="dtd-fragment"> +<pre><!-- Portions © International Organization for Standardization 1986 + Permission to copy in any form is granted for use with + conforming SGML systems and applications as defined in + ISO 8879, provided this notice is included in all copies. +--> +<!-- Character entity set. Typical invocation: + <!ENTITY % HTMLlat1 PUBLIC + "-//W3C//ENTITIES Latin 1//EN//HTML"> + %HTMLlat1; +--> + +<!ENTITY nbsp CDATA "&#160;" -- no-break space = non-breaking space, + U+00A0 ISOnum --> +<!ENTITY iexcl CDATA "&#161;" -- inverted exclamation mark, U+00A1 ISOnum --> +<!ENTITY cent CDATA "&#162;" -- cent sign, U+00A2 ISOnum --> +<!ENTITY pound CDATA "&#163;" -- pound sign, U+00A3 ISOnum --> +<!ENTITY curren CDATA "&#164;" -- currency sign, U+00A4 ISOnum --> +<!ENTITY yen CDATA "&#165;" -- yen sign = yuan sign, U+00A5 ISOnum --> +<!ENTITY brvbar CDATA "&#166;" -- broken bar = broken vertical bar, + U+00A6 ISOnum --> +<!ENTITY sect CDATA "&#167;" -- section sign, U+00A7 ISOnum --> +<!ENTITY uml CDATA "&#168;" -- diaeresis = spacing diaeresis, + U+00A8 ISOdia --> +<!ENTITY copy CDATA "&#169;" -- copyright sign, U+00A9 ISOnum --> +<!ENTITY ordf CDATA "&#170;" -- feminine ordinal indicator, U+00AA ISOnum --> +<!ENTITY laquo CDATA "&#171;" -- left-pointing double angle quotation mark + = left pointing guillemet, U+00AB ISOnum --> +<!ENTITY not CDATA "&#172;" -- not sign, U+00AC ISOnum --> +<!ENTITY shy CDATA "&#173;" -- soft hyphen = discretionary hyphen, + U+00AD ISOnum --> +<!ENTITY reg CDATA "&#174;" -- registered sign = registered trade mark sign, + U+00AE ISOnum --> +<!ENTITY macr CDATA "&#175;" -- macron = spacing macron = overline + = APL overbar, U+00AF ISOdia --> +<!ENTITY deg CDATA "&#176;" -- degree sign, U+00B0 ISOnum --> +<!ENTITY plusmn CDATA "&#177;" -- plus-minus sign = plus-or-minus sign, + U+00B1 ISOnum --> +<!ENTITY sup2 CDATA "&#178;" -- superscript two = superscript digit two + = squared, U+00B2 ISOnum --> +<!ENTITY sup3 CDATA "&#179;" -- superscript three = superscript digit three + = cubed, U+00B3 ISOnum --> +<!ENTITY acute CDATA "&#180;" -- acute accent = spacing acute, + U+00B4 ISOdia --> +<!ENTITY micro CDATA "&#181;" -- micro sign, U+00B5 ISOnum --> +<!ENTITY para CDATA "&#182;" -- pilcrow sign = paragraph sign, + U+00B6 ISOnum --> +<!ENTITY middot CDATA "&#183;" -- middle dot = Georgian comma + = Greek middle dot, U+00B7 ISOnum --> +<!ENTITY cedil CDATA "&#184;" -- cedilla = spacing cedilla, U+00B8 ISOdia --> +<!ENTITY sup1 CDATA "&#185;" -- superscript one = superscript digit one, + U+00B9 ISOnum --> +<!ENTITY ordm CDATA "&#186;" -- masculine ordinal indicator, + U+00BA ISOnum --> +<!ENTITY raquo CDATA "&#187;" -- right-pointing double angle quotation mark + = right pointing guillemet, U+00BB ISOnum --> +<!ENTITY frac14 CDATA "&#188;" -- vulgar fraction one quarter + = fraction one quarter, U+00BC ISOnum --> +<!ENTITY frac12 CDATA "&#189;" -- vulgar fraction one half + = fraction one half, U+00BD ISOnum --> +<!ENTITY frac34 CDATA "&#190;" -- vulgar fraction three quarters + = fraction three quarters, U+00BE ISOnum --> +<!ENTITY iquest CDATA "&#191;" -- inverted question mark + = turned question mark, U+00BF ISOnum --> +<!ENTITY Agrave CDATA "&#192;" -- latin capital letter A with grave + = latin capital letter A grave, + U+00C0 ISOlat1 --> +<!ENTITY Aacute CDATA "&#193;" -- latin capital letter A with acute, + U+00C1 ISOlat1 --> +<!ENTITY Acirc CDATA "&#194;" -- latin capital letter A with circumflex, + U+00C2 ISOlat1 --> +<!ENTITY Atilde CDATA "&#195;" -- latin capital letter A with tilde, + U+00C3 ISOlat1 --> +<!ENTITY Auml CDATA "&#196;" -- latin capital letter A with diaeresis, + U+00C4 ISOlat1 --> +<!ENTITY Aring CDATA "&#197;" -- latin capital letter A with ring above + = latin capital letter A ring, + U+00C5 ISOlat1 --> +<!ENTITY AElig CDATA "&#198;" -- latin capital letter AE + = latin capital ligature AE, + U+00C6 ISOlat1 --> +<!ENTITY Ccedil CDATA "&#199;" -- latin capital letter C with cedilla, + U+00C7 ISOlat1 --> +<!ENTITY Egrave CDATA "&#200;" -- latin capital letter E with grave, + U+00C8 ISOlat1 --> +<!ENTITY Eacute CDATA "&#201;" -- latin capital letter E with acute, + U+00C9 ISOlat1 --> +<!ENTITY Ecirc CDATA "&#202;" -- latin capital letter E with circumflex, + U+00CA ISOlat1 --> +<!ENTITY Euml CDATA "&#203;" -- latin capital letter E with diaeresis, + U+00CB ISOlat1 --> +<!ENTITY Igrave CDATA "&#204;" -- latin capital letter I with grave, + U+00CC ISOlat1 --> +<!ENTITY Iacute CDATA "&#205;" -- latin capital letter I with acute, + U+00CD ISOlat1 --> +<!ENTITY Icirc CDATA "&#206;" -- latin capital letter I with circumflex, + U+00CE ISOlat1 --> +<!ENTITY Iuml CDATA "&#207;" -- latin capital letter I with diaeresis, + U+00CF ISOlat1 --> +<!ENTITY ETH CDATA "&#208;" -- latin capital letter ETH, U+00D0 ISOlat1 --> +<!ENTITY Ntilde CDATA "&#209;" -- latin capital letter N with tilde, + U+00D1 ISOlat1 --> +<!ENTITY Ograve CDATA "&#210;" -- latin capital letter O with grave, + U+00D2 ISOlat1 --> +<!ENTITY Oacute CDATA "&#211;" -- latin capital letter O with acute, + U+00D3 ISOlat1 --> +<!ENTITY Ocirc CDATA "&#212;" -- latin capital letter O with circumflex, + U+00D4 ISOlat1 --> +<!ENTITY Otilde CDATA "&#213;" -- latin capital letter O with tilde, + U+00D5 ISOlat1 --> +<!ENTITY Ouml CDATA "&#214;" -- latin capital letter O with diaeresis, + U+00D6 ISOlat1 --> +<!ENTITY times CDATA "&#215;" -- multiplication sign, U+00D7 ISOnum --> +<!ENTITY Oslash CDATA "&#216;" -- latin capital letter O with stroke + = latin capital letter O slash, + U+00D8 ISOlat1 --> +<!ENTITY Ugrave CDATA "&#217;" -- latin capital letter U with grave, + U+00D9 ISOlat1 --> +<!ENTITY Uacute CDATA "&#218;" -- latin capital letter U with acute, + U+00DA ISOlat1 --> +<!ENTITY Ucirc CDATA "&#219;" -- latin capital letter U with circumflex, + U+00DB ISOlat1 --> +<!ENTITY Uuml CDATA "&#220;" -- latin capital letter U with diaeresis, + U+00DC ISOlat1 --> +<!ENTITY Yacute CDATA "&#221;" -- latin capital letter Y with acute, + U+00DD ISOlat1 --> +<!ENTITY THORN CDATA "&#222;" -- latin capital letter THORN, + U+00DE ISOlat1 --> +<!ENTITY szlig CDATA "&#223;" -- latin small letter sharp s = ess-zed, + U+00DF ISOlat1 --> +<!ENTITY agrave CDATA "&#224;" -- latin small letter a with grave + = latin small letter a grave, + U+00E0 ISOlat1 --> +<!ENTITY aacute CDATA "&#225;" -- latin small letter a with acute, + U+00E1 ISOlat1 --> +<!ENTITY acirc CDATA "&#226;" -- latin small letter a with circumflex, + U+00E2 ISOlat1 --> +<!ENTITY atilde CDATA "&#227;" -- latin small letter a with tilde, + U+00E3 ISOlat1 --> +<!ENTITY auml CDATA "&#228;" -- latin small letter a with diaeresis, + U+00E4 ISOlat1 --> +<!ENTITY aring CDATA "&#229;" -- latin small letter a with ring above + = latin small letter a ring, + U+00E5 ISOlat1 --> +<!ENTITY aelig CDATA "&#230;" -- latin small letter ae + = latin small ligature ae, U+00E6 ISOlat1 --> +<!ENTITY ccedil CDATA "&#231;" -- latin small letter c with cedilla, + U+00E7 ISOlat1 --> +<!ENTITY egrave CDATA "&#232;" -- latin small letter e with grave, + U+00E8 ISOlat1 --> +<!ENTITY eacute CDATA "&#233;" -- latin small letter e with acute, + U+00E9 ISOlat1 --> +<!ENTITY ecirc CDATA "&#234;" -- latin small letter e with circumflex, + U+00EA ISOlat1 --> +<!ENTITY euml CDATA "&#235;" -- latin small letter e with diaeresis, + U+00EB ISOlat1 --> +<!ENTITY igrave CDATA "&#236;" -- latin small letter i with grave, + U+00EC ISOlat1 --> +<!ENTITY iacute CDATA "&#237;" -- latin small letter i with acute, + U+00ED ISOlat1 --> +<!ENTITY icirc CDATA "&#238;" -- latin small letter i with circumflex, + U+00EE ISOlat1 --> +<!ENTITY iuml CDATA "&#239;" -- latin small letter i with diaeresis, + U+00EF ISOlat1 --> +<!ENTITY eth CDATA "&#240;" -- latin small letter eth, U+00F0 ISOlat1 --> +<!ENTITY ntilde CDATA "&#241;" -- latin small letter n with tilde, + U+00F1 ISOlat1 --> +<!ENTITY ograve CDATA "&#242;" -- latin small letter o with grave, + U+00F2 ISOlat1 --> +<!ENTITY oacute CDATA "&#243;" -- latin small letter o with acute, + U+00F3 ISOlat1 --> +<!ENTITY ocirc CDATA "&#244;" -- latin small letter o with circumflex, + U+00F4 ISOlat1 --> +<!ENTITY otilde CDATA "&#245;" -- latin small letter o with tilde, + U+00F5 ISOlat1 --> +<!ENTITY ouml CDATA "&#246;" -- latin small letter o with diaeresis, + U+00F6 ISOlat1 --> +<!ENTITY divide CDATA "&#247;" -- division sign, U+00F7 ISOnum --> +<!ENTITY oslash CDATA "&#248;" -- latin small letter o with stroke, + = latin small letter o slash, + U+00F8 ISOlat1 --> +<!ENTITY ugrave CDATA "&#249;" -- latin small letter u with grave, + U+00F9 ISOlat1 --> +<!ENTITY uacute CDATA "&#250;" -- latin small letter u with acute, + U+00FA ISOlat1 --> +<!ENTITY ucirc CDATA "&#251;" -- latin small letter u with circumflex, + U+00FB ISOlat1 --> +<!ENTITY uuml CDATA "&#252;" -- latin small letter u with diaeresis, + U+00FC ISOlat1 --> +<!ENTITY yacute CDATA "&#253;" -- latin small letter y with acute, + U+00FD ISOlat1 --> +<!ENTITY thorn CDATA "&#254;" -- latin small letter thorn, + U+00FE ISOlat1 --> +<!ENTITY yuml CDATA "&#255;" -- latin small letter y with diaeresis, + U+00FF ISOlat1 --> +</pre> +</div> + +<h2><a name="h-24.3">24.3</a> <a name="sym">Character entity references for +symbols, mathematical symbols, and Greek letters</a></h2> + +<p>The character entity references in this section produce characters that may +be represented by glyphs in the widely available Adobe Symbol font, including +Greek characters, various bracketing symbols, and a selection of mathematical +operators such as gradient, product, and summation symbols.</p> + +<p>To support these entities, user agents may support full <a rel="biblioentry" href="http://www.w3.org/TR/REC-html40/references.html#ref-ISO10646" class="normref">[ISO10646]</a> or use +other means. Display of glyphs for these characters may be obtained by being +able to display the relevant <a rel="biblioentry" href="http://www.w3.org/TR/REC-html40/references.html#ref-ISO10646" class="normref">[ISO10646]</a> characters or +by other means, such as internally mapping the listed entities, numeric +character references, and characters to the appropriate position in some font +that contains the requisite glyphs.</p> + +<div class="note"> +<p><em><strong>When to use Greek entities.</strong> This entity set contains +all the letters used in modern Greek. However, it does not include Greek +punctuation, precomposed accented characters nor the non-spacing accents +(tonos, dialytika) required to compose them. There are no archaic letters, +Coptic-unique letters, or precomposed letters for Polytonic Greek. The entities +defined here are not intended for the representation of modern Greek text and +would not be an efficient representation; rather, they are intended for +occasional Greek letters used in technical and mathematical works.</em></p> +</div> + +<h3><a name="h-24.3.1">24.3.1</a> The list of characters</h3> + +<div class="dtd-fragment"> +<pre><!-- Mathematical, Greek and Symbolic characters for HTML --> + +<!-- Character entity set. Typical invocation: + <!ENTITY % HTMLsymbol PUBLIC + "-//W3C//ENTITIES Symbols//EN//HTML"> + %HTMLsymbol; --> + +<!-- Portions © International Organization for Standardization 1986: + Permission to copy in any form is granted for use with + conforming SGML systems and applications as defined in + ISO 8879, provided this notice is included in all copies. +--> + +<!-- Relevant ISO entity set is given unless names are newly introduced. + New names (i.e., not in ISO 8879 list) do not clash with any + existing ISO 8879 entity names. ISO 10646 character numbers + are given for each character, in hex. CDATA values are decimal + conversions of the ISO 10646 values and refer to the document + character set. Names are ISO 10646 names. + +--> + +<!-- Latin Extended-B --> +<!ENTITY fnof CDATA "&#402;" -- latin small f with hook = function + = florin, U+0192 ISOtech --> + +<!-- Greek --> +<!ENTITY Alpha CDATA "&#913;" -- greek capital letter alpha, U+0391 --> +<!ENTITY Beta CDATA "&#914;" -- greek capital letter beta, U+0392 --> +<!ENTITY Gamma CDATA "&#915;" -- greek capital letter gamma, + U+0393 ISOgrk3 --> +<!ENTITY Delta CDATA "&#916;" -- greek capital letter delta, + U+0394 ISOgrk3 --> +<!ENTITY Epsilon CDATA "&#917;" -- greek capital letter epsilon, U+0395 --> +<!ENTITY Zeta CDATA "&#918;" -- greek capital letter zeta, U+0396 --> +<!ENTITY Eta CDATA "&#919;" -- greek capital letter eta, U+0397 --> +<!ENTITY Theta CDATA "&#920;" -- greek capital letter theta, + U+0398 ISOgrk3 --> +<!ENTITY Iota CDATA "&#921;" -- greek capital letter iota, U+0399 --> +<!ENTITY Kappa CDATA "&#922;" -- greek capital letter kappa, U+039A --> +<!ENTITY Lambda CDATA "&#923;" -- greek capital letter lambda, + U+039B ISOgrk3 --> +<!ENTITY Mu CDATA "&#924;" -- greek capital letter mu, U+039C --> +<!ENTITY Nu CDATA "&#925;" -- greek capital letter nu, U+039D --> +<!ENTITY Xi CDATA "&#926;" -- greek capital letter xi, U+039E ISOgrk3 --> +<!ENTITY Omicron CDATA "&#927;" -- greek capital letter omicron, U+039F --> +<!ENTITY Pi CDATA "&#928;" -- greek capital letter pi, U+03A0 ISOgrk3 --> +<!ENTITY Rho CDATA "&#929;" -- greek capital letter rho, U+03A1 --> +<!-- there is no Sigmaf, and no U+03A2 character either --> +<!ENTITY Sigma CDATA "&#931;" -- greek capital letter sigma, + U+03A3 ISOgrk3 --> +<!ENTITY Tau CDATA "&#932;" -- greek capital letter tau, U+03A4 --> +<!ENTITY Upsilon CDATA "&#933;" -- greek capital letter upsilon, + U+03A5 ISOgrk3 --> +<!ENTITY Phi CDATA "&#934;" -- greek capital letter phi, + U+03A6 ISOgrk3 --> +<!ENTITY Chi CDATA "&#935;" -- greek capital letter chi, U+03A7 --> +<!ENTITY Psi CDATA "&#936;" -- greek capital letter psi, + U+03A8 ISOgrk3 --> +<!ENTITY Omega CDATA "&#937;" -- greek capital letter omega, + U+03A9 ISOgrk3 --> + +<!ENTITY alpha CDATA "&#945;" -- greek small letter alpha, + U+03B1 ISOgrk3 --> +<!ENTITY beta CDATA "&#946;" -- greek small letter beta, U+03B2 ISOgrk3 --> +<!ENTITY gamma CDATA "&#947;" -- greek small letter gamma, + U+03B3 ISOgrk3 --> +<!ENTITY delta CDATA "&#948;" -- greek small letter delta, + U+03B4 ISOgrk3 --> +<!ENTITY epsilon CDATA "&#949;" -- greek small letter epsilon, + U+03B5 ISOgrk3 --> +<!ENTITY zeta CDATA "&#950;" -- greek small letter zeta, U+03B6 ISOgrk3 --> +<!ENTITY eta CDATA "&#951;" -- greek small letter eta, U+03B7 ISOgrk3 --> +<!ENTITY theta CDATA "&#952;" -- greek small letter theta, + U+03B8 ISOgrk3 --> +<!ENTITY iota CDATA "&#953;" -- greek small letter iota, U+03B9 ISOgrk3 --> +<!ENTITY kappa CDATA "&#954;" -- greek small letter kappa, + U+03BA ISOgrk3 --> +<!ENTITY lambda CDATA "&#955;" -- greek small letter lambda, + U+03BB ISOgrk3 --> +<!ENTITY mu CDATA "&#956;" -- greek small letter mu, U+03BC ISOgrk3 --> +<!ENTITY nu CDATA "&#957;" -- greek small letter nu, U+03BD ISOgrk3 --> +<!ENTITY xi CDATA "&#958;" -- greek small letter xi, U+03BE ISOgrk3 --> +<!ENTITY omicron CDATA "&#959;" -- greek small letter omicron, U+03BF NEW --> +<!ENTITY pi CDATA "&#960;" -- greek small letter pi, U+03C0 ISOgrk3 --> +<!ENTITY rho CDATA "&#961;" -- greek small letter rho, U+03C1 ISOgrk3 --> +<!ENTITY sigmaf CDATA "&#962;" -- greek small letter final sigma, + U+03C2 ISOgrk3 --> +<!ENTITY sigma CDATA "&#963;" -- greek small letter sigma, + U+03C3 ISOgrk3 --> +<!ENTITY tau CDATA "&#964;" -- greek small letter tau, U+03C4 ISOgrk3 --> +<!ENTITY upsilon CDATA "&#965;" -- greek small letter upsilon, + U+03C5 ISOgrk3 --> +<!ENTITY phi CDATA "&#966;" -- greek small letter phi, U+03C6 ISOgrk3 --> +<!ENTITY chi CDATA "&#967;" -- greek small letter chi, U+03C7 ISOgrk3 --> +<!ENTITY psi CDATA "&#968;" -- greek small letter psi, U+03C8 ISOgrk3 --> +<!ENTITY omega CDATA "&#969;" -- greek small letter omega, + U+03C9 ISOgrk3 --> +<!ENTITY thetasym CDATA "&#977;" -- greek small letter theta symbol, + U+03D1 NEW --> +<!ENTITY upsih CDATA "&#978;" -- greek upsilon with hook symbol, + U+03D2 NEW --> +<!ENTITY piv CDATA "&#982;" -- greek pi symbol, U+03D6 ISOgrk3 --> + +<!-- General Punctuation --> +<!ENTITY bull CDATA "&#8226;" -- bullet = black small circle, + U+2022 ISOpub --> +<!-- bullet is NOT the same as bullet operator, U+2219 --> +<!ENTITY hellip CDATA "&#8230;" -- horizontal ellipsis = three dot leader, + U+2026 ISOpub --> +<!ENTITY prime CDATA "&#8242;" -- prime = minutes = feet, U+2032 ISOtech --> +<!ENTITY Prime CDATA "&#8243;" -- double prime = seconds = inches, + U+2033 ISOtech --> +<!ENTITY oline CDATA "&#8254;" -- overline = spacing overscore, + U+203E NEW --> +<!ENTITY frasl CDATA "&#8260;" -- fraction slash, U+2044 NEW --> + +<!-- Letterlike Symbols --> +<!ENTITY weierp CDATA "&#8472;" -- script capital P = power set + = Weierstrass p, U+2118 ISOamso --> +<!ENTITY image CDATA "&#8465;" -- blackletter capital I = imaginary part, + U+2111 ISOamso --> +<!ENTITY real CDATA "&#8476;" -- blackletter capital R = real part symbol, + U+211C ISOamso --> +<!ENTITY trade CDATA "&#8482;" -- trade mark sign, U+2122 ISOnum --> +<!ENTITY alefsym CDATA "&#8501;" -- alef symbol = first transfinite cardinal, + U+2135 NEW --> +<!-- alef symbol is NOT the same as hebrew letter alef, + U+05D0 although the same glyph could be used to depict both characters --> + +<!-- Arrows --> +<!ENTITY larr CDATA "&#8592;" -- leftwards arrow, U+2190 ISOnum --> +<!ENTITY uarr CDATA "&#8593;" -- upwards arrow, U+2191 ISOnum--> +<!ENTITY rarr CDATA "&#8594;" -- rightwards arrow, U+2192 ISOnum --> +<!ENTITY darr CDATA "&#8595;" -- downwards arrow, U+2193 ISOnum --> +<!ENTITY harr CDATA "&#8596;" -- left right arrow, U+2194 ISOamsa --> +<!ENTITY crarr CDATA "&#8629;" -- downwards arrow with corner leftwards + = carriage return, U+21B5 NEW --> +<!ENTITY lArr CDATA "&#8656;" -- leftwards double arrow, U+21D0 ISOtech --> +<!-- ISO 10646 does not say that lArr is the same as the 'is implied by' arrow + but also does not have any other character for that function. So ? lArr can + be used for 'is implied by' as ISOtech suggests --> +<!ENTITY uArr CDATA "&#8657;" -- upwards double arrow, U+21D1 ISOamsa --> +<!ENTITY rArr CDATA "&#8658;" -- rightwards double arrow, + U+21D2 ISOtech --> +<!-- ISO 10646 does not say this is the 'implies' character but does not have + another character with this function so ? + rArr can be used for 'implies' as ISOtech suggests --> +<!ENTITY dArr CDATA "&#8659;" -- downwards double arrow, U+21D3 ISOamsa --> +<!ENTITY hArr CDATA "&#8660;" -- left right double arrow, + U+21D4 ISOamsa --> + +<!-- Mathematical Operators --> +<!ENTITY forall CDATA "&#8704;" -- for all, U+2200 ISOtech --> +<!ENTITY part CDATA "&#8706;" -- partial differential, U+2202 ISOtech --> +<!ENTITY exist CDATA "&#8707;" -- there exists, U+2203 ISOtech --> +<!ENTITY empty CDATA "&#8709;" -- empty set = null set = diameter, + U+2205 ISOamso --> +<!ENTITY nabla CDATA "&#8711;" -- nabla = backward difference, + U+2207 ISOtech --> +<!ENTITY isin CDATA "&#8712;" -- element of, U+2208 ISOtech --> +<!ENTITY notin CDATA "&#8713;" -- not an element of, U+2209 ISOtech --> +<!ENTITY ni CDATA "&#8715;" -- contains as member, U+220B ISOtech --> +<!-- should there be a more memorable name than 'ni'? --> +<!ENTITY prod CDATA "&#8719;" -- n-ary product = product sign, + U+220F ISOamsb --> +<!-- prod is NOT the same character as U+03A0 'greek capital letter pi' though + the same glyph might be used for both --> +<!ENTITY sum CDATA "&#8721;" -- n-ary sumation, U+2211 ISOamsb --> +<!-- sum is NOT the same character as U+03A3 'greek capital letter sigma' + though the same glyph might be used for both --> +<!ENTITY minus CDATA "&#8722;" -- minus sign, U+2212 ISOtech --> +<!ENTITY lowast CDATA "&#8727;" -- asterisk operator, U+2217 ISOtech --> +<!ENTITY radic CDATA "&#8730;" -- square root = radical sign, + U+221A ISOtech --> +<!ENTITY prop CDATA "&#8733;" -- proportional to, U+221D ISOtech --> +<!ENTITY infin CDATA "&#8734;" -- infinity, U+221E ISOtech --> +<!ENTITY ang CDATA "&#8736;" -- angle, U+2220 ISOamso --> +<!ENTITY and CDATA "&#8743;" -- logical and = wedge, U+2227 ISOtech --> +<!ENTITY or CDATA "&#8744;" -- logical or = vee, U+2228 ISOtech --> +<!ENTITY cap CDATA "&#8745;" -- intersection = cap, U+2229 ISOtech --> +<!ENTITY cup CDATA "&#8746;" -- union = cup, U+222A ISOtech --> +<!ENTITY int CDATA "&#8747;" -- integral, U+222B ISOtech --> +<!ENTITY there4 CDATA "&#8756;" -- therefore, U+2234 ISOtech --> +<!ENTITY sim CDATA "&#8764;" -- tilde operator = varies with = similar to, + U+223C ISOtech --> +<!-- tilde operator is NOT the same character as the tilde, U+007E, + although the same glyph might be used to represent both --> +<!ENTITY cong CDATA "&#8773;" -- approximately equal to, U+2245 ISOtech --> +<!ENTITY asymp CDATA "&#8776;" -- almost equal to = asymptotic to, + U+2248 ISOamsr --> +<!ENTITY ne CDATA "&#8800;" -- not equal to, U+2260 ISOtech --> +<!ENTITY equiv CDATA "&#8801;" -- identical to, U+2261 ISOtech --> +<!ENTITY le CDATA "&#8804;" -- less-than or equal to, U+2264 ISOtech --> +<!ENTITY ge CDATA "&#8805;" -- greater-than or equal to, + U+2265 ISOtech --> +<!ENTITY sub CDATA "&#8834;" -- subset of, U+2282 ISOtech --> +<!ENTITY sup CDATA "&#8835;" -- superset of, U+2283 ISOtech --> +<!-- note that nsup, 'not a superset of, U+2283' is not covered by the Symbol + font encoding and is not included. Should it be, for symmetry? + It is in ISOamsn --> +<!ENTITY nsub CDATA "&#8836;" -- not a subset of, U+2284 ISOamsn --> +<!ENTITY sube CDATA "&#8838;" -- subset of or equal to, U+2286 ISOtech --> +<!ENTITY supe CDATA "&#8839;" -- superset of or equal to, + U+2287 ISOtech --> +<!ENTITY oplus CDATA "&#8853;" -- circled plus = direct sum, + U+2295 ISOamsb --> +<!ENTITY otimes CDATA "&#8855;" -- circled times = vector product, + U+2297 ISOamsb --> +<!ENTITY perp CDATA "&#8869;" -- up tack = orthogonal to = perpendicular, + U+22A5 ISOtech --> +<!ENTITY sdot CDATA "&#8901;" -- dot operator, U+22C5 ISOamsb --> +<!-- dot operator is NOT the same character as U+00B7 middle dot --> + +<!-- Miscellaneous Technical --> +<!ENTITY lceil CDATA "&#8968;" -- left ceiling = apl upstile, + U+2308 ISOamsc --> +<!ENTITY rceil CDATA "&#8969;" -- right ceiling, U+2309 ISOamsc --> +<!ENTITY lfloor CDATA "&#8970;" -- left floor = apl downstile, + U+230A ISOamsc --> +<!ENTITY rfloor CDATA "&#8971;" -- right floor, U+230B ISOamsc --> +<!ENTITY lang CDATA "&#9001;" -- left-pointing angle bracket = bra, + U+2329 ISOtech --> +<!-- lang is NOT the same character as U+003C 'less than' + or U+2039 'single left-pointing angle quotation mark' --> +<!ENTITY rang CDATA "&#9002;" -- right-pointing angle bracket = ket, + U+232A ISOtech --> +<!-- rang is NOT the same character as U+003E 'greater than' + or U+203A 'single right-pointing angle quotation mark' --> + +<!-- Geometric Shapes --> +<!ENTITY loz CDATA "&#9674;" -- lozenge, U+25CA ISOpub --> + +<!-- Miscellaneous Symbols --> +<!ENTITY spades CDATA "&#9824;" -- black spade suit, U+2660 ISOpub --> +<!-- black here seems to mean filled as opposed to hollow --> +<!ENTITY clubs CDATA "&#9827;" -- black club suit = shamrock, + U+2663 ISOpub --> +<!ENTITY hearts CDATA "&#9829;" -- black heart suit = valentine, + U+2665 ISOpub --> +<!ENTITY diams CDATA "&#9830;" -- black diamond suit, U+2666 ISOpub --> +</pre> +</div> + +<h2><a name="h-24.4">24.4</a> <a name="misc">Character entity references for +markup-significant and internationalization characters</a></h2> + +<p>The character entity references in this section are for escaping +markup-significant characters (these are the same as those in HTML 2.0 and +3.2), for denoting spaces and dashes. Other characters in this section apply to +internationalization issues such as the disambiguation of bidirectional text +(see the section on <a href="http://www.w3.org/TR/REC-html40/struct/dirlang.html#bidirection">bidirectional +text</a> for details).</p> + +<p>Entities have also been added for the remaining characters occurring in +CP-1252 which do not occur in the HTMLlat1 or HTMLsymbol entity sets. These all +occur in the 128 to 159 range within the CP-1252 charset. These entities permit +the characters to be denoted in a platform-independent manner.</p> + +<p>To support these entities, user agents may support full <a rel="biblioentry" href="http://www.w3.org/TR/REC-html40/references.html#ref-ISO10646" class="normref">[ISO10646]</a> or use +other means. Display of glyphs for these characters may be obtained by being +able to display the relevant <a rel="biblioentry" href="http://www.w3.org/TR/REC-html40/references.html#ref-ISO10646" class="normref">[ISO10646]</a> characters or +by other means, such as internally mapping the listed entities, numeric +character references, and characters to the appropriate position in some font +that contains the requisite glyphs.</p> + +<h3><a name="h-24.4.1">24.4.1</a> The list of characters</h3> + +<div class="dtd-fragment"> +<pre><!-- Special characters for HTML --> + +<!-- Character entity set. Typical invocation: + <!ENTITY % HTMLspecial PUBLIC + "-//W3C//ENTITIES Special//EN//HTML"> + %HTMLspecial; --> + +<!-- Portions © International Organization for Standardization 1986: + Permission to copy in any form is granted for use with + conforming SGML systems and applications as defined in + ISO 8879, provided this notice is included in all copies. +--> + +<!-- Relevant ISO entity set is given unless names are newly introduced. + New names (i.e., not in ISO 8879 list) do not clash with any + existing ISO 8879 entity names. ISO 10646 character numbers + are given for each character, in hex. CDATA values are decimal + conversions of the ISO 10646 values and refer to the document + character set. Names are ISO 10646 names. + +--> + +<!-- C0 Controls and Basic Latin --> +<!ENTITY quot CDATA "&#34;" -- quotation mark = APL quote, + U+0022 ISOnum --> +<!ENTITY amp CDATA "&#38;" -- ampersand, U+0026 ISOnum --> +<!ENTITY lt CDATA "&#60;" -- less-than sign, U+003C ISOnum --> +<!ENTITY gt CDATA "&#62;" -- greater-than sign, U+003E ISOnum --> + +<!-- Latin Extended-A --> +<!ENTITY OElig CDATA "&#338;" -- latin capital ligature OE, + U+0152 ISOlat2 --> +<!ENTITY oelig CDATA "&#339;" -- latin small ligature oe, U+0153 ISOlat2 --> +<!-- ligature is a misnomer, this is a separate character in some languages --> +<!ENTITY Scaron CDATA "&#352;" -- latin capital letter S with caron, + U+0160 ISOlat2 --> +<!ENTITY scaron CDATA "&#353;" -- latin small letter s with caron, + U+0161 ISOlat2 --> +<!ENTITY Yuml CDATA "&#376;" -- latin capital letter Y with diaeresis, + U+0178 ISOlat2 --> + +<!-- Spacing Modifier Letters --> +<!ENTITY circ CDATA "&#710;" -- modifier letter circumflex accent, + U+02C6 ISOpub --> +<!ENTITY tilde CDATA "&#732;" -- small tilde, U+02DC ISOdia --> + +<!-- General Punctuation --> +<!ENTITY ensp CDATA "&#8194;" -- en space, U+2002 ISOpub --> +<!ENTITY emsp CDATA "&#8195;" -- em space, U+2003 ISOpub --> +<!ENTITY thinsp CDATA "&#8201;" -- thin space, U+2009 ISOpub --> +<!ENTITY zwnj CDATA "&#8204;" -- zero width non-joiner, + U+200C NEW RFC 2070 --> +<!ENTITY zwj CDATA "&#8205;" -- zero width joiner, U+200D NEW RFC 2070 --> +<!ENTITY lrm CDATA "&#8206;" -- left-to-right mark, U+200E NEW RFC 2070 --> +<!ENTITY rlm CDATA "&#8207;" -- right-to-left mark, U+200F NEW RFC 2070 --> +<!ENTITY ndash CDATA "&#8211;" -- en dash, U+2013 ISOpub --> +<!ENTITY mdash CDATA "&#8212;" -- em dash, U+2014 ISOpub --> +<!ENTITY lsquo CDATA "&#8216;" -- left single quotation mark, + U+2018 ISOnum --> +<!ENTITY rsquo CDATA "&#8217;" -- right single quotation mark, + U+2019 ISOnum --> +<!ENTITY sbquo CDATA "&#8218;" -- single low-9 quotation mark, U+201A NEW --> +<!ENTITY ldquo CDATA "&#8220;" -- left double quotation mark, + U+201C ISOnum --> +<!ENTITY rdquo CDATA "&#8221;" -- right double quotation mark, + U+201D ISOnum --> +<!ENTITY bdquo CDATA "&#8222;" -- double low-9 quotation mark, U+201E NEW --> +<!ENTITY dagger CDATA "&#8224;" -- dagger, U+2020 ISOpub --> +<!ENTITY Dagger CDATA "&#8225;" -- double dagger, U+2021 ISOpub --> +<!ENTITY permil CDATA "&#8240;" -- per mille sign, U+2030 ISOtech --> +<!ENTITY lsaquo CDATA "&#8249;" -- single left-pointing angle quotation mark, + U+2039 ISO proposed --> +<!-- lsaquo is proposed but not yet ISO standardized --> +<!ENTITY rsaquo CDATA "&#8250;" -- single right-pointing angle quotation mark, + U+203A ISO proposed --> +<!-- rsaquo is proposed but not yet ISO standardized --> +<!ENTITY euro CDATA "&#8364;" -- euro sign, U+20AC NEW --> +</pre> +</div> + +<div class="navbar" align="center"> +<hr><a href="http://www.w3.org/TR/REC-html40/sgml/framesetdtd.html">previous</a> <a href="http://www.w3.org/TR/REC-html40/appendix/changes.html">next</a> <a href="http://www.w3.org/TR/REC-html40/cover.html#minitoc"> +contents</a> <a href="http://www.w3.org/TR/REC-html40/index/elements.html">elements</a> <a href="http://www.w3.org/TR/REC-html40/index/attributes.html">attributes</a> <a href="http://www.w3.org/TR/REC-html40/index/list.html">index</a></div> +</body></html>
\ No newline at end of file diff --git a/Build/source/libs/gd/libgd-2.1.1/src/entities.tcl b/Build/source/libs/gd/libgd-2.1.1/src/entities.tcl new file mode 100644 index 00000000000..1f7c9e7e4af --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/entities.tcl @@ -0,0 +1,50 @@ +#!/usr/bin/tclsh + +# get names for html-4.0 characters from: +# http://www.w3.org/TR/REC-html40/sgml/entities.html +set f [open entities.html r] +set entity_name_length_max 0 +set nr_of_entities 0 +while {! [eof $f]} { + set rec [gets $f] + if {[scan $rec {<!ENTITY %s CDATA "&#%d;"; --} name val] == 2} { + set entity($name) $val + set entity_name_length [string length $name] + if {$entity_name_length > $entity_name_length_max} { + set entity_name_length_max $entity_name_length + } + incr nr_of_entities + } +} +close $f + +set f [open entities.h w] +puts $f "/*" +puts $f " * Generated file - do not edit directly." +puts $f " *" +puts $f " * This file was generated from:" +puts $f " * http://www.w3.org/TR/REC-html40/sgml/entities.html" +puts $f " * by means of the script:" +puts $f " * entities.tcl" +puts $f " */" +puts $f "" +puts $f "#ifdef __cplusplus" +puts $f "extern \"C\" {" +puts $f "#endif" +puts $f "" +puts $f "static struct entities_s {" +puts $f " char *name;" +puts $f " int value;" +puts $f "} entities\[\] = {" +foreach name [lsort [array names entity]] { + puts $f " {\"$name\", $entity($name)}," +} +puts $f "};" +puts $f "" +puts $f "#define ENTITY_NAME_LENGTH_MAX $entity_name_length_max" +puts $f "#define NR_OF_ENTITIES $nr_of_entities" +puts $f "" +puts $f "#ifdef __cplusplus" +puts $f "}" +puts $f "#endif" +close $f diff --git a/Build/source/libs/gd/libgd-2.1.1/src/fontconfigtest.c b/Build/source/libs/gd/libgd-2.1.1/src/fontconfigtest.c new file mode 100644 index 00000000000..47c484922db --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/fontconfigtest.c @@ -0,0 +1,44 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gd.h" + +int main (int argc, char *argv[]) +{ + gdImagePtr im; + int green, blue; + gdFTStringExtra se; + FILE *out; + im = gdImageCreateTrueColor(300, 100); + green = gdImageColorAllocate(im, 128, 255, 128); + gdImageFilledRectangle(im, 0, 0, 300, 100, green); + blue = gdImageColorAllocate(im, 128, 128, 255); + /* Default: fontlist argument is a pathname to a truetype font */ + gdImageStringFT(im, 0, blue, "arial", + 12, 0, 20, 20, "plain pathname default"); + /* Specifically opt for fontconfig */ + se.flags = gdFTEX_FONTCONFIG; + gdImageStringFTEx(im, 0, blue, "arial:bold", + 12, 0, 20, 40, "fontconfig arial:bold", &se); + /* Change the default to fontconfig */ + if (!gdFTUseFontConfig(1)) { + fprintf(stderr, "fontconfig not compiled into gd\n"); + } + /* Use fontconfig by (newly set) default */ + gdImageStringFT(im, 0, blue, "arial:bold", + 12, 0, 20, 60, "fontconfig arial:bold default"); + /* Explicitly use a pathname despite fontconfig default */ + se.flags = gdFTEX_FONTPATHNAME; + gdImageStringFTEx(im, 0, blue, "arial", + 12, 0, 20, 80, "plain pathname", &se); +#ifdef HAVE_LIBPNG + out = fopen("fontconfigtest.png", "wb"); + gdImagePng(im, out); + fclose(out); +#else + fprintf(stderr, "PNG not compiled into gd\n"); +#endif /* HAVE_LIBPNG */ + return 0; +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/fontsizetest.c b/Build/source/libs/gd/libgd-2.1.1/src/fontsizetest.c new file mode 100644 index 00000000000..55b9209d051 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/fontsizetest.c @@ -0,0 +1,97 @@ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gd.h" + +void +dosizes (gdImagePtr im, int color, char *fontfile, + int x, int y, const char *string) +{ + int brect[8]; + double curang = 0.0; + char *cp; + int cursize; + char buf[60]; + + for (cursize = 1; cursize <= 20; cursize++) { + sprintf (buf, "%d: %s", cursize, string); + + /* The case of newlines is taken care of in the gdImageStringTTF call */ +#if defined(OLDER_GD) + cp = + gdImageStringTTF (im, brect, color, fontfile, cursize, curang, x, y, + buf); +#else + cp = + gdImageStringFT (im, brect, color, fontfile, cursize, curang, x, y, + buf); +#endif + if (cp) + fprintf(stderr, "%s\n", cp); + y += cursize + 4; + + /* render the same fontsize with antialiasing turned off */ +#if defined(OLDER_GD) + cp = + gdImageStringTTF (im, brect, 0 - color, fontfile, cursize, curang, x, + y, buf); +#else + cp = + gdImageStringFT (im, brect, 0 - color, fontfile, cursize, curang, x, + y, buf); +#endif + if (cp) + fprintf(stderr, "%s\n", cp); + y += cursize + 4; + } +} + +void +dotest (char *font, int w, int h, char *string, const char *filename) +{ + gdImagePtr im; + FILE *out; + int bg; + int fc; + + im = gdImageCreate (w, h); + bg = gdImageColorAllocate (im, 0, 0, 0); + + gdImageFilledRectangle (im, 1, 1, w - 1, h - 1, bg); + + fc = gdImageColorAllocate (im, 255, 192, 192); + + out = fopen (filename, "wb"); + + dosizes (im, fc, font, 20, 20, string); + +#if defined(HAVE_LIBPNG) + gdImagePng (im, out); +#elif defined(HAVE_LIBJPEG) + gdImageJpeg (im, out, -1); +#endif + fclose (out); +} + +int +main(void) +{ + +#if defined(HAVE_LIBPNG) + dotest ("times", 400, 600, ".....Hello, there!", "fontsizetest1.png"); + dotest ("cour", 400, 600, ".....Hello, there!", "fontsizetest2.png"); + dotest ("arial", 400, 600, ".....Hello, there!", "fontsizetest3.png"); + dotest ("luximr", 400, 600, ".....Hello, there!", "fontsizetest4.png"); +#elif defined(HAVE_LIBJPEG) + dotest ("times", 400, 600, ".....Hello, there!", "fontsizetest1.jpeg"); + dotest ("cour", 400, 600, ".....Hello, there!", "fontsizetest2.jpeg"); + dotest ("arial", 400, 600, ".....Hello, there!", "fontsizetest3.jpeg"); + dotest ("luximr", 400, 600, ".....Hello, there!", "fontsizetest4.jpeg"); +#else + fprintf(stderr, "no PNG or JPEG support\n"); +#endif + + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/fontwheeltest.c b/Build/source/libs/gd/libgd-2.1.1/src/fontwheeltest.c new file mode 100644 index 00000000000..b2bb258fdad --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/fontwheeltest.c @@ -0,0 +1,142 @@ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <math.h> +#include "gd.h" +#define DEGTORAD(x) ( (x) * (2.0 * 3.14159265) / 360.0 ) + +void +doerr (FILE * err, const char *msg) +{ + if (err) { + fprintf (err, "%s\n", msg); + fflush (err); + } +} + +void +dowheel (gdImagePtr im, int color, char *fontfile, int fontsize, + double angle, int x, int y, int offset, char *string) +{ + int brect[8]; + FILE *err; + double curangrads, curang, x0, y0; + char *cp; + + err = fopen ("err.out", "a"); + doerr (err, "------------- New fontwheel --------------"); + doerr (err, fontfile); + doerr (err, string); + doerr (err, "------------------------------------------"); + + for (curang = 0.0; curang < 360.0; curang += angle) { + curangrads = DEGTORAD(curang); + x0 = x + cos (curangrads) * offset; + y0 = y - sin (curangrads) * offset; + + /* The case of newlines is taken care of in the gdImageStringTTF call */ +#if defined(OLDER_GD) + cp = gdImageStringTTF (im, brect, color, fontfile, fontsize, + curangrads, x0, y0, string); +#else + cp = gdImageStringFT (im, brect, color, fontfile, fontsize, + curangrads, x0, y0, string); +#endif + if (cp) + doerr (err, cp); + + gdImagePolygon (im, (gdPointPtr)brect, 4, color); + } + + fclose (err); +} + +#if 0 +void +dolines (gdImagePtr im, int color, double incr, int x, int y, int offset, + int length) +{ + double curang; + double angle; + double x0, x1, y0, y1; + for (curang = 0.0; curang < 360.0; curang += incr) { + angle = curang * (2.0 * 3.14159265) / 360.0; + x0 = cos (angle) * offset + x; + x1 = cos (angle) * (offset + length) + x; + y0 = sin (angle) * offset + y; + y1 = sin (angle) * (offset + length) + y; + gdImageLine (im, x0, y0, x1, y1, color); + } +} +#endif + +void +dotest (char *font, int size, double incr, + int w, int h, char *string, const char *filename) +{ + gdImagePtr im; + FILE *out; + int bg; + int fc; +#if 0 + int lc; +#endif + int xc = w / 2; + int yc = h / 2; + + im = gdImageCreate (w, h); + bg = gdImageColorAllocate (im, 0, 0, 0); + + gdImageFilledRectangle (im, 1, 1, w - 1, h - 1, bg); + + fc = gdImageColorAllocate (im, 255, 192, 192); +#if 0 + lc = gdImageColorAllocate (im, 192, 255, 255); +#endif + + out = fopen (filename, "wb"); + + dowheel (im, fc, font, size, incr, xc, yc, 20, string); +#if 0 + dolines (im, lc, incr, xc, yc, 20, 120); +#endif + +#if defined(HAVE_LIBPNG) + gdImagePng (im, out); +#elif defined(HAVE_LIBJPEG) + gdImageJpeg (im, out, -1); +#endif + + fclose (out); +} + +int +main(void) +{ + +#if defined(HAVE_LIBPNG) + dotest ("times", 16, 20.0, 400, 400, "Hello, there!", + "fontwheeltest1.png"); + dotest ("times", 16, 30.0, 400, 400, "Hello, there!", + "fontwheeltest2.png"); + dotest ("arial", 16, 45.0, 400, 400, "Hello, there!", + "fontwheeltest3.png"); + dotest ("arial", 16, 90.0, 400, 400, "Hello\nthere!", + "fontwheeltest4.png"); +#elif defined(HAVE_LIBJPEG) + dotest ("times", 16, 20.0, 400, 400, "Hello, there!", + "fontwheeltest1.jpeg"); + dotest ("times", 16, 30.0, 400, 400, "Hello, there!", + "fontwheeltest2.jpeg"); + dotest ("arial", 16, 45.0, 400, 400, "Hello, there!", + "fontwheeltest3.jpeg"); + dotest ("arial", 16, 90.0, 400, 400, "Hello\nthere!", + "fontwheeltest4.jpeg"); +#else + fprintf(stderr, "no PNG or JPEG support\n"); +#endif + + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd.c b/Build/source/libs/gd/libgd-2.1.1/src/gd.c new file mode 100644 index 00000000000..cc698a0923f --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd.c @@ -0,0 +1,3660 @@ +/* $Id$ */ + +#include <stdio.h> +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include <stdarg.h> + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gd_intern.h" + +/* 2.03: don't include zlib here or we can't build without PNG */ +#include "gd.h" +#include "gdhelpers.h" +#include "gd_color.h" +#include "gd_errors.h" + +/* 2.0.12: this now checks the clipping rectangle */ +#define gdImageBoundsSafeMacro(im, x, y) (!((((y) < (im)->cy1) || ((y) > (im)->cy2)) || (((x) < (im)->cx1) || ((x) > (im)->cx2)))) + +#ifdef _OSD_POSIX /* BS2000 uses the EBCDIC char set instead of ASCII */ +#define CHARSET_EBCDIC +#define __attribute__(any) /*nothing */ +#endif +/*_OSD_POSIX*/ + +#ifndef CHARSET_EBCDIC +#define ASC(ch) ch +#else /*CHARSET_EBCDIC */ +#define ASC(ch) gd_toascii[(unsigned char)ch] +static const unsigned char gd_toascii[256] = { + /*00 */ 0x00, 0x01, 0x02, 0x03, 0x85, 0x09, 0x86, 0x7f, + 0x87, 0x8d, 0x8e, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, /*................ */ + /*10 */ 0x10, 0x11, 0x12, 0x13, 0x8f, 0x0a, 0x08, 0x97, + 0x18, 0x19, 0x9c, 0x9d, 0x1c, 0x1d, 0x1e, 0x1f, /*................ */ + /*20 */ 0x80, 0x81, 0x82, 0x83, 0x84, 0x92, 0x17, 0x1b, + 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x05, 0x06, 0x07, /*................ */ + /*30 */ 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04, + 0x98, 0x99, 0x9a, 0x9b, 0x14, 0x15, 0x9e, 0x1a, /*................ */ + /*40 */ 0x20, 0xa0, 0xe2, 0xe4, 0xe0, 0xe1, 0xe3, 0xe5, + 0xe7, 0xf1, 0x60, 0x2e, 0x3c, 0x28, 0x2b, 0x7c, /* .........`.<(+| */ + /*50 */ 0x26, 0xe9, 0xea, 0xeb, 0xe8, 0xed, 0xee, 0xef, + 0xec, 0xdf, 0x21, 0x24, 0x2a, 0x29, 0x3b, 0x9f, /*&.........!$*);. */ + /*60 */ 0x2d, 0x2f, 0xc2, 0xc4, 0xc0, 0xc1, 0xc3, 0xc5, + 0xc7, 0xd1, 0x5e, 0x2c, 0x25, 0x5f, 0x3e, 0x3f, + /*-/........^,%_>?*/ + /*70 */ 0xf8, 0xc9, 0xca, 0xcb, 0xc8, 0xcd, 0xce, 0xcf, + 0xcc, 0xa8, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22, /*..........:#@'=" */ + /*80 */ 0xd8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, + 0x68, 0x69, 0xab, 0xbb, 0xf0, 0xfd, 0xfe, 0xb1, /*.abcdefghi...... */ + /*90 */ 0xb0, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, + 0x71, 0x72, 0xaa, 0xba, 0xe6, 0xb8, 0xc6, 0xa4, /*.jklmnopqr...... */ + /*a0 */ 0xb5, 0xaf, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, + 0x79, 0x7a, 0xa1, 0xbf, 0xd0, 0xdd, 0xde, 0xae, /*..stuvwxyz...... */ + /*b0 */ 0xa2, 0xa3, 0xa5, 0xb7, 0xa9, 0xa7, 0xb6, 0xbc, + 0xbd, 0xbe, 0xac, 0x5b, 0x5c, 0x5d, 0xb4, 0xd7, /*...........[\].. */ + /*c0 */ 0xf9, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, + 0x48, 0x49, 0xad, 0xf4, 0xf6, 0xf2, 0xf3, 0xf5, /*.ABCDEFGHI...... */ + /*d0 */ 0xa6, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, + 0x51, 0x52, 0xb9, 0xfb, 0xfc, 0xdb, 0xfa, 0xff, /*.JKLMNOPQR...... */ + /*e0 */ 0xd9, 0xf7, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, + 0x59, 0x5a, 0xb2, 0xd4, 0xd6, 0xd2, 0xd3, 0xd5, /*..STUVWXYZ...... */ + /*f0 */ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, + 0x38, 0x39, 0xb3, 0x7b, 0xdc, 0x7d, 0xda, 0x7e /*0123456789.{.}.~ */ +}; +#endif /*CHARSET_EBCDIC */ + +extern const int gdCosT[]; +extern const int gdSinT[]; + +void gd_stderr_error(int priority, const char *format, va_list args) +{ + switch (priority) { + case GD_ERROR: + fputs("GD Error: ", stderr); + break; + case GD_WARNING: + fputs("GD Warning: ", stderr); + break; + case GD_NOTICE: + fputs("GD Notice: ", stderr); + break; + case GD_INFO: + fputs("GD Info: ", stderr); + break; + case GD_DEBUG: + fputs("GD Debug: ", stderr); + break; + } + vfprintf(stderr, format, args); + fflush(stderr); +} + +static gdErrorMethod gd_error_method = gd_stderr_error; + +void gd_error(const char *format, ...) +{ + va_list args; + + va_start(args, format); + gd_error_ex(GD_WARNING, format, args); + va_end(args); +} +void gd_error_ex(int priority, const char *format, ...) +{ + va_list args; + + va_start(args, format); + if (gd_error_method) { + gd_error_method(priority, format, args); + } + va_end(args); +} + +BGD_DECLARE(void) gdSetErrorMethod(gdErrorMethod error_method) +{ + gd_error_method = error_method; +} + +BGD_DECLARE(void) gdClearErrorMethod(void) +{ + gd_error_method = gd_stderr_error; +} + +static void gdImageBrushApply (gdImagePtr im, int x, int y); +static void gdImageTileApply (gdImagePtr im, int x, int y); +BGD_DECLARE(int) gdImageGetTrueColorPixel (gdImagePtr im, int x, int y); + + +/* + Function: gdImageCreate + + gdImageCreate is called to create palette-based images, with no + more than 256 colors. The image must eventually be destroyed using + gdImageDestroy(). + + Parameters: + + sx - The image width. + sy - The image height. + + Returns: + + A pointer to the new image or NULL if an error occurred. + + Example: + + > gdImagePtr im; + > im = gdImageCreate(64, 64); + > // ... Use the image ... + > gdImageDestroy(im); + + See Also: + + <gdImageCreateTrueColor> + + */ +BGD_DECLARE(gdImagePtr) gdImageCreate (int sx, int sy) +{ + int i; + gdImagePtr im; + + if (overflow2(sizeof (unsigned char *), sy)) { + return NULL; + } + if (overflow2(sizeof (unsigned char *), sx)) { + return NULL; + } + + im = (gdImage *) gdCalloc(1, sizeof(gdImage)); + if (!im) { + return NULL; + } + + /* Row-major ever since gd 1.3 */ + im->pixels = (unsigned char **) gdMalloc (sizeof (unsigned char *) * sy); + if (!im->pixels) { + gdFree(im); + return NULL; + } + + im->polyInts = 0; + im->polyAllocated = 0; + im->brush = 0; + im->tile = 0; + im->style = 0; + for (i = 0; (i < sy); i++) { + /* Row-major ever since gd 1.3 */ + im->pixels[i] = (unsigned char *) gdCalloc (sx, sizeof (unsigned char)); + if (!im->pixels[i]) { + for (--i ; i >= 0; i--) { + gdFree(im->pixels[i]); + } + gdFree(im->pixels); + gdFree(im); + return NULL; + } + + } + im->sx = sx; + im->sy = sy; + im->colorsTotal = 0; + im->transparent = (-1); + im->interlace = 0; + im->thick = 1; + im->AA = 0; + for (i = 0; (i < gdMaxColors); i++) { + im->open[i] = 1; + }; + im->trueColor = 0; + im->tpixels = 0; + im->cx1 = 0; + im->cy1 = 0; + im->cx2 = im->sx - 1; + im->cy2 = im->sy - 1; + im->res_x = GD_RESOLUTION; + im->res_y = GD_RESOLUTION; + im->interpolation = NULL; + im->interpolation_id = GD_BILINEAR_FIXED; + return im; +} + + + +/* + Function: gdImageCreateTrueColor + + <gdImageCreateTrueColor> is called to create truecolor images, + with an essentially unlimited number of colors. Invoke + <gdImageCreateTrueColor> with the x and y dimensions of the + desired image. <gdImageCreateTrueColor> returns a <gdImagePtr> + to the new image, or NULL if unable to allocate the image. The + image must eventually be destroyed using <gdImageDestroy>(). + + Truecolor images are always filled with black at creation + time. There is no concept of a "background" color index. + + Parameters: + + sx - The image width. + sy - The image height. + + Returns: + + A pointer to the new image or NULL if an error occurred. + + Example: + + > gdImagePtr im; + > im = gdImageCreateTrueColor(64, 64); + > // ... Use the image ... + > gdImageDestroy(im); + + See Also: + + <gdImageCreateTrueColor> + +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateTrueColor (int sx, int sy) +{ + int i; + gdImagePtr im; + + if (overflow2(sx, sy)) { + return NULL; + } + + if (overflow2(sizeof (int *), sy)) { + return 0; + } + + if (overflow2(sizeof(int), sx)) { + return NULL; + } + + im = (gdImage *) gdMalloc (sizeof (gdImage)); + if (!im) { + return 0; + } + memset (im, 0, sizeof (gdImage)); + + im->tpixels = (int **) gdMalloc (sizeof (int *) * sy); + if (!im->tpixels) { + gdFree(im); + return 0; + } + im->polyInts = 0; + im->polyAllocated = 0; + im->brush = 0; + im->tile = 0; + im->style = 0; + for (i = 0; (i < sy); i++) { + im->tpixels[i] = (int *) gdCalloc (sx, sizeof (int)); + if (!im->tpixels[i]) { + /* 2.0.34 */ + i--; + while (i >= 0) { + gdFree(im->tpixels[i]); + i--; + } + gdFree(im->tpixels); + gdFree(im); + return 0; + } + } + im->sx = sx; + im->sy = sy; + im->transparent = (-1); + im->interlace = 0; + im->trueColor = 1; + /* 2.0.2: alpha blending is now on by default, and saving of alpha is + off by default. This allows font antialiasing to work as expected + on the first try in JPEGs -- quite important -- and also allows + for smaller PNGs when saving of alpha channel is not really + desired, which it usually isn't! */ + im->saveAlphaFlag = 0; + im->alphaBlendingFlag = 1; + im->thick = 1; + im->AA = 0; + im->cx1 = 0; + im->cy1 = 0; + im->cx2 = im->sx - 1; + im->cy2 = im->sy - 1; + im->res_x = GD_RESOLUTION; + im->res_y = GD_RESOLUTION; + im->interpolation = NULL; + im->interpolation_id = GD_BILINEAR_FIXED; + return im; +} + +/* + Function: gdImageDestroy + + <gdImageDestroy> is used to free the memory associated with an + image. It is important to invoke <gdImageDestroy> before exiting + your program or assigning a new image to a <gdImagePtr> variable. + + Parameters: + + im - Pointer to the gdImage to delete. + + Returns: + + Nothing. + + Example: + + > gdImagePtr im; + > im = gdImageCreate(10, 10); + > // ... Use the image ... + > // Now destroy it + > gdImageDestroy(im); + +*/ + +BGD_DECLARE(void) gdImageDestroy (gdImagePtr im) +{ + int i; + if (im->pixels) { + for (i = 0; (i < im->sy); i++) { + gdFree (im->pixels[i]); + } + gdFree (im->pixels); + } + if (im->tpixels) { + for (i = 0; (i < im->sy); i++) { + gdFree (im->tpixels[i]); + } + gdFree (im->tpixels); + } + if (im->polyInts) { + gdFree (im->polyInts); + } + if (im->style) { + gdFree (im->style); + } + gdFree (im); +} + +BGD_DECLARE(int) gdImageColorClosest (gdImagePtr im, int r, int g, int b) +{ + return gdImageColorClosestAlpha (im, r, g, b, gdAlphaOpaque); +} + +BGD_DECLARE(int) gdImageColorClosestAlpha (gdImagePtr im, int r, int g, int b, int a) +{ + int i; + long rd, gd, bd, ad; + int ct = (-1); + int first = 1; + long mindist = 0; + if (im->trueColor) { + return gdTrueColorAlpha (r, g, b, a); + } + for (i = 0; (i < (im->colorsTotal)); i++) { + long dist; + if (im->open[i]) { + continue; + } + rd = (im->red[i] - r); + gd = (im->green[i] - g); + bd = (im->blue[i] - b); + /* gd 2.02: whoops, was - b (thanks to David Marwood) */ + /* gd 2.16: was blue rather than alpha! Geez! Thanks to + Artur Jakub Jerzak */ + ad = (im->alpha[i] - a); + dist = rd * rd + gd * gd + bd * bd + ad * ad; + if (first || (dist < mindist)) { + mindist = dist; + ct = i; + first = 0; + } + } + return ct; +} + +/* This code is taken from http://www.acm.org/jgt/papers/SmithLyons96/hwb_rgb.html, an article + * on colour conversion to/from RBG and HWB colour systems. + * It has been modified to return the converted value as a * parameter. + */ + +#define RETURN_HWB(h, w, b) {HWB->H = h; HWB->W = w; HWB->B = b; return HWB;} +#define RETURN_RGB(r, g, b) {RGB->R = r; RGB->G = g; RGB->B = b; return RGB;} +#define HWB_UNDEFINED -1 +#define SETUP_RGB(s, r, g, b) {s.R = r/255.0; s.G = g/255.0; s.B = b/255.0;} + +#define MIN(a,b) ((a)<(b)?(a):(b)) +#define MIN3(a,b,c) ((a)<(b)?(MIN(a,c)):(MIN(b,c))) +#define MAX(a,b) ((a)<(b)?(b):(a)) +#define MAX3(a,b,c) ((a)<(b)?(MAX(b,c)):(MAX(a,c))) + + +/* + * Theoretically, hue 0 (pure red) is identical to hue 6 in these transforms. Pure + * red always maps to 6 in this implementation. Therefore UNDEFINED can be + * defined as 0 in situations where only unsigned numbers are desired. + */ +typedef struct { + float R, G, B; +} +RGBType; +typedef struct { + float H, W, B; +} +HWBType; + +static HWBType * +RGB_to_HWB (RGBType RGB, HWBType * HWB) +{ + + /* + * RGB are each on [0, 1]. W and B are returned on [0, 1] and H is + * returned on [0, 6]. Exception: H is returned UNDEFINED if W == 1 - B. + */ + + float R = RGB.R, G = RGB.G, B = RGB.B, w, v, b, f; + int i; + + w = MIN3 (R, G, B); + v = MAX3 (R, G, B); + b = 1 - v; + if (v == w) + RETURN_HWB (HWB_UNDEFINED, w, b); + f = (R == w) ? G - B : ((G == w) ? B - R : R - G); + i = (R == w) ? 3 : ((G == w) ? 5 : 1); + RETURN_HWB (i - f / (v - w), w, b); + +} + +static float +HWB_Diff (int r1, int g1, int b1, int r2, int g2, int b2) +{ + RGBType RGB1, RGB2; + HWBType HWB1, HWB2; + float diff; + + SETUP_RGB (RGB1, r1, g1, b1); + SETUP_RGB (RGB2, r2, g2, b2); + + RGB_to_HWB (RGB1, &HWB1); + RGB_to_HWB (RGB2, &HWB2); + + /* + * I made this bit up; it seems to produce OK results, and it is certainly + * more visually correct than the current RGB metric. (PJW) + */ + + if ((HWB1.H == HWB_UNDEFINED) || (HWB2.H == HWB_UNDEFINED)) { + diff = 0; /* Undefined hues always match... */ + } else { + diff = fabs (HWB1.H - HWB2.H); + if (diff > 3) { + diff = 6 - diff; /* Remember, it's a colour circle */ + } + } + + diff = + diff * diff + (HWB1.W - HWB2.W) * (HWB1.W - HWB2.W) + (HWB1.B - + HWB2.B) * (HWB1.B - + HWB2.B); + + return diff; +} + + +#if 0 +/* + * This is not actually used, but is here for completeness, in case someone wants to + * use the HWB stuff for anything else... + */ +static RGBType * +HWB_to_RGB (HWBType HWB, RGBType * RGB) +{ + + /* + * H is given on [0, 6] or UNDEFINED. W and B are given on [0, 1]. + * RGB are each returned on [0, 1]. + */ + + float h = HWB.H, w = HWB.W, b = HWB.B, v, n, f; + int i; + + v = 1 - b; + if (h == HWB_UNDEFINED) + RETURN_RGB (v, v, v); + i = floor (h); + f = h - i; + if (i & 1) + f = 1 - f; /* if i is odd */ + n = w + f * (v - w); /* linear interpolation between w and v */ + switch (i) { + case 6: + case 0: + RETURN_RGB (v, n, w); + case 1: + RETURN_RGB (n, v, w); + case 2: + RETURN_RGB (w, v, n); + case 3: + RETURN_RGB (w, n, v); + case 4: + RETURN_RGB (n, w, v); + case 5: + RETURN_RGB (v, w, n); + } + + return RGB; + +} +#endif + +BGD_DECLARE(int) gdImageColorClosestHWB (gdImagePtr im, int r, int g, int b) +{ + int i; + /* long rd, gd, bd; */ + int ct = (-1); + int first = 1; + float mindist = 0; + if (im->trueColor) { + return gdTrueColor (r, g, b); + } + for (i = 0; (i < (im->colorsTotal)); i++) { + float dist; + if (im->open[i]) { + continue; + } + dist = HWB_Diff (im->red[i], im->green[i], im->blue[i], r, g, b); + if (first || (dist < mindist)) { + mindist = dist; + ct = i; + first = 0; + } + } + return ct; +} + +BGD_DECLARE(int) gdImageColorExact (gdImagePtr im, int r, int g, int b) +{ + return gdImageColorExactAlpha (im, r, g, b, gdAlphaOpaque); +} + +BGD_DECLARE(int) gdImageColorExactAlpha (gdImagePtr im, int r, int g, int b, int a) +{ + int i; + if (im->trueColor) { + return gdTrueColorAlpha (r, g, b, a); + } + for (i = 0; (i < (im->colorsTotal)); i++) { + if (im->open[i]) { + continue; + } + if ((im->red[i] == r) && + (im->green[i] == g) && (im->blue[i] == b) && (im->alpha[i] == a)) { + return i; + } + } + return -1; +} + +BGD_DECLARE(int) gdImageColorAllocate (gdImagePtr im, int r, int g, int b) +{ + return gdImageColorAllocateAlpha (im, r, g, b, gdAlphaOpaque); +} + +BGD_DECLARE(int) gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a) +{ + int i; + int ct = (-1); + if (im->trueColor) { + return gdTrueColorAlpha (r, g, b, a); + } + for (i = 0; (i < (im->colorsTotal)); i++) { + if (im->open[i]) { + ct = i; + break; + } + } + if (ct == (-1)) { + ct = im->colorsTotal; + if (ct == gdMaxColors) { + return -1; + } + im->colorsTotal++; + } + im->red[ct] = r; + im->green[ct] = g; + im->blue[ct] = b; + im->alpha[ct] = a; + im->open[ct] = 0; + return ct; +} + +/* + * gdImageColorResolve is an alternative for the code fragment: + * + * if ((color=gdImageColorExact(im,R,G,B)) < 0) + * if ((color=gdImageColorAllocate(im,R,G,B)) < 0) + * color=gdImageColorClosest(im,R,G,B); + * + * in a single function. Its advantage is that it is guaranteed to + * return a color index in one search over the color table. + */ + +BGD_DECLARE(int) gdImageColorResolve (gdImagePtr im, int r, int g, int b) +{ + return gdImageColorResolveAlpha (im, r, g, b, gdAlphaOpaque); +} + +BGD_DECLARE(int) gdImageColorResolveAlpha (gdImagePtr im, int r, int g, int b, int a) +{ + int c; + int ct = -1; + int op = -1; + long rd, gd, bd, ad, dist; + long mindist = 4 * 255 * 255; /* init to max poss dist */ + if (im->trueColor) { + return gdTrueColorAlpha (r, g, b, a); + } + + for (c = 0; c < im->colorsTotal; c++) { + if (im->open[c]) { + op = c; /* Save open slot */ + continue; /* Color not in use */ + } + if (c == im->transparent) { + /* don't ever resolve to the color that has + * been designated as the transparent color */ + continue; + } + rd = (long) (im->red[c] - r); + gd = (long) (im->green[c] - g); + bd = (long) (im->blue[c] - b); + ad = (long) (im->alpha[c] - a); + dist = rd * rd + gd * gd + bd * bd + ad * ad; + if (dist < mindist) { + if (dist == 0) { + return c; /* Return exact match color */ + } + mindist = dist; + ct = c; + } + } + /* no exact match. We now know closest, but first try to allocate exact */ + if (op == -1) { + op = im->colorsTotal; + if (op == gdMaxColors) { + /* No room for more colors */ + return ct; /* Return closest available color */ + } + im->colorsTotal++; + } + im->red[op] = r; + im->green[op] = g; + im->blue[op] = b; + im->alpha[op] = a; + im->open[op] = 0; + return op; /* Return newly allocated color */ +} + +BGD_DECLARE(void) gdImageColorDeallocate (gdImagePtr im, int color) +{ + if (im->trueColor || (color >= gdMaxColors) || (color < 0)) { + return; + } + /* Mark it open. */ + im->open[color] = 1; +} + +BGD_DECLARE(void) gdImageColorTransparent (gdImagePtr im, int color) +{ + if (!im->trueColor) { + if((color < -1) || (color >= gdMaxColors)) { + return; + } + if (im->transparent != -1) { + im->alpha[im->transparent] = gdAlphaOpaque; + } + if (color != -1) { + im->alpha[color] = gdAlphaTransparent; + } + } + im->transparent = color; +} + +BGD_DECLARE(void) gdImagePaletteCopy (gdImagePtr to, gdImagePtr from) +{ + int i; + int x, y, p; + int xlate[256]; + if (to->trueColor) { + return; + } + if (from->trueColor) { + return; + } + + for (i = 0; i < 256; i++) { + xlate[i] = -1; + }; + + for (y = 0; y < (to->sy); y++) { + for (x = 0; x < (to->sx); x++) { + /* Optimization: no gdImageGetPixel */ + p = to->pixels[y][x]; + if (xlate[p] == -1) { + /* This ought to use HWB, but we don't have an alpha-aware + version of that yet. */ + xlate[p] = + gdImageColorClosestAlpha (from, to->red[p], to->green[p], + to->blue[p], to->alpha[p]); + /*printf("Mapping %d (%d, %d, %d, %d) to %d (%d, %d, %d, %d)\n", */ + /* p, to->red[p], to->green[p], to->blue[p], to->alpha[p], */ + /* xlate[p], from->red[xlate[p]], from->green[xlate[p]], from->blue[xlate[p]], from->alpha[xlate[p]]); */ + }; + /* Optimization: no gdImageSetPixel */ + to->pixels[y][x] = xlate[p]; + }; + }; + + for (i = 0; (i < (from->colorsTotal)); i++) { + /*printf("Copying color %d (%d, %d, %d, %d)\n", i, from->red[i], from->blue[i], from->green[i], from->alpha[i]); */ + to->red[i] = from->red[i]; + to->blue[i] = from->blue[i]; + to->green[i] = from->green[i]; + to->alpha[i] = from->alpha[i]; + to->open[i] = 0; + }; + + for (i = from->colorsTotal; (i < to->colorsTotal); i++) { + to->open[i] = 1; + }; + + to->colorsTotal = from->colorsTotal; + +} + +BGD_DECLARE(int) gdImageColorReplace (gdImagePtr im, int src, int dst) +{ + register int x, y; + int n = 0; + + if (src == dst) { + return 0; + } + +#define REPLACING_LOOP(pixel) do { \ + for (y = im->cy1; y <= im->cy2; y++) { \ + for (x = im->cx1; x <= im->cx2; x++) { \ + if (pixel(im, x, y) == src) { \ + gdImageSetPixel(im, x, y, dst); \ + n++; \ + } \ + } \ + } \ + } while (0) + + if (im->trueColor) { + REPLACING_LOOP(gdImageTrueColorPixel); + } else { + REPLACING_LOOP(gdImagePalettePixel); + } + +#undef REPLACING_LOOP + + return n; +} + +BGD_DECLARE(int) gdImageColorReplaceThreshold (gdImagePtr im, int src, int dst, float threshold) +{ + register int x, y; + int n = 0; + + if (src == dst) { + return 0; + } + +#define REPLACING_LOOP(pixel) do { \ + for (y = im->cy1; y <= im->cy2; y++) { \ + for (x = im->cx1; x <= im->cx2; x++) { \ + if (gdColorMatch(im, src, pixel(im, x, y), threshold)) { \ + gdImageSetPixel(im, x, y, dst); \ + n++; \ + } \ + } \ + } \ + } while (0) + + if (im->trueColor) { + REPLACING_LOOP(gdImageTrueColorPixel); + } else { + REPLACING_LOOP(gdImagePalettePixel); + } + +#undef REPLACING_LOOP + + return n; +} + +static int colorCmp (const void *x, const void *y) +{ + int a = *(int const *)x; + int b = *(int const *)y; + return (a > b) - (a < b); +} + +BGD_DECLARE(int) gdImageColorReplaceArray (gdImagePtr im, int len, int *src, int *dst) +{ + register int x, y; + int c, *d, *base; + int i, n = 0; + + if (len <= 0 || src == dst) { + return 0; + } + if (len == 1) { + return gdImageColorReplace(im, src[0], dst[0]); + } + if (overflow2(len, sizeof(int)<<1)) { + return -1; + } + base = (int *)gdMalloc(len * (sizeof(int)<<1)); + if (!base) { + return -1; + } + for (i = 0; i < len; i++) { + base[(i<<1)] = src[i]; + base[(i<<1)+1] = dst[i]; + } + qsort(base, len, sizeof(int)<<1, colorCmp); + +#define REPLACING_LOOP(pixel) do { \ + for (y = im->cy1; y <= im->cy2; y++) { \ + for (x = im->cx1; x <= im->cx2; x++) { \ + c = pixel(im, x, y); \ + if ( (d = (int *)bsearch(&c, base, len, sizeof(int)<<1, colorCmp)) ) { \ + gdImageSetPixel(im, x, y, d[1]); \ + n++; \ + } \ + } \ + } \ + } while (0) + + if (im->trueColor) { + REPLACING_LOOP(gdImageTrueColorPixel); + } else { + REPLACING_LOOP(gdImagePalettePixel); + } + +#undef REPLACING_LOOP + + gdFree(base); + return n; +} + +BGD_DECLARE(int) gdImageColorReplaceCallback (gdImagePtr im, gdCallbackImageColor callback) +{ + int c, d, n = 0; + + if (!callback) { + return 0; + } + if (im->trueColor) { + register int x, y; + + for (y = im->cy1; y <= im->cy2; y++) { + for (x = im->cx1; x <= im->cx2; x++) { + c = gdImageTrueColorPixel(im, x, y); + if ( (d = callback(im, c)) != c) { + gdImageSetPixel(im, x, y, d); + n++; + } + } + } + } else { /* palette */ + int *sarr, *darr; + int k, len = 0; + + sarr = (int *)gdCalloc(im->colorsTotal, sizeof(int)); + if (!sarr) { + return -1; + } + for (c = 0; c < im->colorsTotal; c++) { + if (!im->open[c]) { + sarr[len++] = c; + } + } + darr = (int *)gdCalloc(len, sizeof(int)); + if (!darr) { + gdFree(sarr); + return -1; + } + for (k = 0; k < len; k++) { + darr[k] = callback(im, sarr[k]); + } + n = gdImageColorReplaceArray(im, k, sarr, darr); + gdFree(darr); + gdFree(sarr); + } + return n; +} + +/* 2.0.10: before the drawing routines, some code to clip points that are + * outside the drawing window. Nick Atty (nick@canalplan.org.uk) + * + * This is the Sutherland Hodgman Algorithm, as implemented by + * Duvanenko, Robbins and Gyurcsik - SH(DRG) for short. See Dr Dobb's + * Journal, January 1996, pp107-110 and 116-117 + * + * Given the end points of a line, and a bounding rectangle (which we + * know to be from (0,0) to (SX,SY)), adjust the endpoints to be on + * the edges of the rectangle if the line should be drawn at all, + * otherwise return a failure code */ + +/* this does "one-dimensional" clipping: note that the second time it + is called, all the x parameters refer to height and the y to width + - the comments ignore this (if you can understand it when it's + looking at the X parameters, it should become clear what happens on + the second call!) The code is simplified from that in the article, + as we know that gd images always start at (0,0) */ + +/* 2.0.26, TBB: we now have to respect a clipping rectangle, it won't + necessarily start at 0. */ + +static int +clip_1d (int *x0, int *y0, int *x1, int *y1, int mindim, int maxdim) +{ + double m; /* gradient of line */ + if (*x0 < mindim) { + /* start of line is left of window */ + if (*x1 < mindim) /* as is the end, so the line never cuts the window */ + return 0; + m = (*y1 - *y0) / (double) (*x1 - *x0); /* calculate the slope of the line */ + /* adjust x0 to be on the left boundary (ie to be zero), and y0 to match */ + *y0 -= (int)(m * (*x0 - mindim)); + *x0 = mindim; + /* now, perhaps, adjust the far end of the line as well */ + if (*x1 > maxdim) { + *y1 += m * (maxdim - *x1); + *x1 = maxdim; + } + return 1; + } + if (*x0 > maxdim) { + /* start of line is right of window - + complement of above */ + if (*x1 > maxdim) /* as is the end, so the line misses the window */ + return 0; + m = (*y1 - *y0) / (double) (*x1 - *x0); /* calculate the slope of the line */ + *y0 += (int)(m * (maxdim - *x0)); /* adjust so point is on the right + boundary */ + *x0 = maxdim; + /* now, perhaps, adjust the end of the line */ + if (*x1 < mindim) { + *y1 -= (int)(m * (*x1 - mindim)); + *x1 = mindim; + } + return 1; + } + /* the final case - the start of the line is inside the window */ + if (*x1 > maxdim) { + /* other end is outside to the right */ + m = (*y1 - *y0) / (double) (*x1 - *x0); /* calculate the slope of the line */ + *y1 += (int)(m * (maxdim - *x1)); + *x1 = maxdim; + return 1; + } + if (*x1 < mindim) { + /* other end is outside to the left */ + m = (*y1 - *y0) / (double) (*x1 - *x0); /* calculate the slope of the line */ + *y1 -= (int)(m * (*x1 - mindim)); + *x1 = mindim; + return 1; + } + /* only get here if both points are inside the window */ + return 1; +} + +/* end of line clipping code */ + +BGD_DECLARE(void) gdImageSetPixel (gdImagePtr im, int x, int y, int color) +{ + int p; + switch (color) { + case gdStyled: + if (!im->style) { + /* Refuse to draw if no style is set. */ + return; + } else { + p = im->style[im->stylePos++]; + } + if (p != (gdTransparent)) { + gdImageSetPixel (im, x, y, p); + } + im->stylePos = im->stylePos % im->styleLength; + break; + case gdStyledBrushed: + if (!im->style) { + /* Refuse to draw if no style is set. */ + return; + } + p = im->style[im->stylePos++]; + if ((p != gdTransparent) && (p != 0)) { + gdImageSetPixel (im, x, y, gdBrushed); + } + im->stylePos = im->stylePos % im->styleLength; + break; + case gdBrushed: + gdImageBrushApply (im, x, y); + break; + case gdTiled: + gdImageTileApply (im, x, y); + break; + case gdAntiAliased: + /* This shouldn't happen (2.0.26) because we just call + gdImageAALine now, but do something sane. */ + gdImageSetPixel(im, x, y, im->AA_color); + break; + default: + if (gdImageBoundsSafeMacro (im, x, y)) { + if (im->trueColor) { + switch (im->alphaBlendingFlag) { + default: + case gdEffectReplace: + im->tpixels[y][x] = color; + break; + case gdEffectAlphaBlend: + case gdEffectNormal: + im->tpixels[y][x] = gdAlphaBlend(im->tpixels[y][x], color); + break; + case gdEffectOverlay : + im->tpixels[y][x] = gdLayerOverlay(im->tpixels[y][x], color); + break; + case gdEffectMultiply : + im->tpixels[y][x] = gdLayerMultiply(im->tpixels[y][x], color); + break; + } + } else { + im->pixels[y][x] = color; + } + } + break; + } +} + +static void +gdImageBrushApply (gdImagePtr im, int x, int y) +{ + int lx, ly; + int hy; + int hx; + int x1, y1, x2, y2; + int srcx, srcy; + if (!im->brush) { + return; + } + hy = gdImageSY (im->brush) / 2; + y1 = y - hy; + y2 = y1 + gdImageSY (im->brush); + hx = gdImageSX (im->brush) / 2; + x1 = x - hx; + x2 = x1 + gdImageSX (im->brush); + srcy = 0; + if (im->trueColor) { + if (im->brush->trueColor) { + for (ly = y1; (ly < y2); ly++) { + srcx = 0; + for (lx = x1; (lx < x2); lx++) { + int p; + p = gdImageGetTrueColorPixel (im->brush, srcx, srcy); + /* 2.0.9, Thomas Winzig: apply simple full transparency */ + if (p != gdImageGetTransparent (im->brush)) { + gdImageSetPixel (im, lx, ly, p); + } + srcx++; + } + srcy++; + } + } else { + /* 2.0.12: Brush palette, image truecolor (thanks to Thorben Kundinger + for pointing out the issue) */ + for (ly = y1; (ly < y2); ly++) { + srcx = 0; + for (lx = x1; (lx < x2); lx++) { + int p, tc; + p = gdImageGetPixel (im->brush, srcx, srcy); + tc = gdImageGetTrueColorPixel (im->brush, srcx, srcy); + /* 2.0.9, Thomas Winzig: apply simple full transparency */ + if (p != gdImageGetTransparent (im->brush)) { + gdImageSetPixel (im, lx, ly, tc); + } + srcx++; + } + srcy++; + } + } + } else { + for (ly = y1; (ly < y2); ly++) { + srcx = 0; + for (lx = x1; (lx < x2); lx++) { + int p; + p = gdImageGetPixel (im->brush, srcx, srcy); + /* Allow for non-square brushes! */ + if (p != gdImageGetTransparent (im->brush)) { + /* Truecolor brush. Very slow + on a palette destination. */ + if (im->brush->trueColor) { + gdImageSetPixel (im, lx, ly, + gdImageColorResolveAlpha (im, + gdTrueColorGetRed + (p), + gdTrueColorGetGreen + (p), + gdTrueColorGetBlue + (p), + gdTrueColorGetAlpha + (p))); + } else { + gdImageSetPixel (im, lx, ly, im->brushColorMap[p]); + } + } + srcx++; + } + srcy++; + } + } +} + +static void +gdImageTileApply (gdImagePtr im, int x, int y) +{ + gdImagePtr tile = im->tile; + int srcx, srcy; + int p; + if (!tile) { + return; + } + srcx = x % gdImageSX (tile); + srcy = y % gdImageSY (tile); + if (im->trueColor) { + p = gdImageGetPixel (tile, srcx, srcy); + if (p != gdImageGetTransparent (tile)) { + if (!tile->trueColor) { + p = gdTrueColorAlpha(tile->red[p], tile->green[p], tile->blue[p], tile->alpha[p]); + } + gdImageSetPixel (im, x, y, p); + } + } else { + p = gdImageGetPixel (tile, srcx, srcy); + /* Allow for transparency */ + if (p != gdImageGetTransparent (tile)) { + if (tile->trueColor) { + /* Truecolor tile. Very slow + on a palette destination. */ + gdImageSetPixel (im, x, y, + gdImageColorResolveAlpha (im, + gdTrueColorGetRed + (p), + gdTrueColorGetGreen + (p), + gdTrueColorGetBlue + (p), + gdTrueColorGetAlpha + (p))); + } else { + gdImageSetPixel (im, x, y, im->tileColorMap[p]); + } + } + } +} + +BGD_DECLARE(int) gdImageGetPixel (gdImagePtr im, int x, int y) +{ + if (gdImageBoundsSafeMacro (im, x, y)) { + if (im->trueColor) { + return im->tpixels[y][x]; + } else { + return im->pixels[y][x]; + } + } else { + return 0; + } +} + +BGD_DECLARE(int) gdImageGetTrueColorPixel (gdImagePtr im, int x, int y) +{ + int p = gdImageGetPixel (im, x, y); + if (!im->trueColor) { + return gdTrueColorAlpha (im->red[p], im->green[p], im->blue[p], + (im->transparent == p) ? gdAlphaTransparent : + im->alpha[p]); + } else { + return p; + } +} + +BGD_DECLARE(void) gdImageAABlend (gdImagePtr im) +{ + /* NO-OP, kept for library compatibility. */ + (void)im; +} + +static void gdImageAALine (gdImagePtr im, int x1, int y1, int x2, int y2, int col); + +static void gdImageHLine(gdImagePtr im, int y, int x1, int x2, int col) +{ + if (im->thick > 1) { + int thickhalf = im->thick >> 1; + gdImageFilledRectangle(im, x1, y - thickhalf, x2, y + im->thick - thickhalf - 1, col); + } else { + if (x2 < x1) { + int t = x2; + x2 = x1; + x1 = t; + } + + for (; x1 <= x2; x1++) { + gdImageSetPixel(im, x1, y, col); + } + } + return; +} + +static void gdImageVLine(gdImagePtr im, int x, int y1, int y2, int col) +{ + if (im->thick > 1) { + int thickhalf = im->thick >> 1; + gdImageFilledRectangle(im, x - thickhalf, y1, x + im->thick - thickhalf - 1, y2, col); + } else { + if (y2 < y1) { + int t = y1; + y1 = y2; + y2 = t; + } + + for (; y1 <= y2; y1++) { + gdImageSetPixel(im, x, y1, col); + } + } + return; +} + +/* Bresenham as presented in Foley & Van Dam */ +BGD_DECLARE(void) gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color) +{ + int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag; + int wid; + int w, wstart; + int thick; + + if (color == gdAntiAliased) { + /* + gdAntiAliased passed as color: use the much faster, much cheaper + and equally attractive gdImageAALine implementation. That + clips too, so don't clip twice. + */ + gdImageAALine(im, x1, y1, x2, y2, im->AA_color); + return; + } + /* 2.0.10: Nick Atty: clip to edges of drawing rectangle, return if no + points need to be drawn. 2.0.26, TBB: clip to edges of clipping + rectangle. We were getting away with this because gdImageSetPixel + is used for actual drawing, but this is still more efficient and opens + the way to skip per-pixel bounds checking in the future. */ + + if (clip_1d (&x1, &y1, &x2, &y2, im->cx1, im->cx2) == 0) + return; + if (clip_1d (&y1, &x1, &y2, &x2, im->cy1, im->cy2) == 0) + return; + thick = im->thick; + + dx = abs (x2 - x1); + dy = abs (y2 - y1); + + if (dx == 0) { + gdImageVLine(im, x1, y1, y2, color); + return; + } else if (dy == 0) { + gdImageHLine(im, y1, x1, x2, color); + return; + } + + if (dy <= dx) { + /* More-or-less horizontal. use wid for vertical stroke */ + /* Doug Claar: watch out for NaN in atan2 (2.0.5) */ + if ((dx == 0) && (dy == 0)) { + wid = 1; + } else { + /* 2.0.12: Michael Schwartz: divide rather than multiply; + TBB: but watch out for /0! */ + double ac = cos (atan2 (dy, dx)); + if (ac != 0) { + wid = thick / ac; + } else { + wid = 1; + } + if (wid == 0) { + wid = 1; + } + } + d = 2 * dy - dx; + incr1 = 2 * dy; + incr2 = 2 * (dy - dx); + if (x1 > x2) { + x = x2; + y = y2; + ydirflag = (-1); + xend = x1; + } else { + x = x1; + y = y1; + ydirflag = 1; + xend = x2; + } + + /* Set up line thickness */ + wstart = y - wid / 2; + for (w = wstart; w < wstart + wid; w++) + gdImageSetPixel (im, x, w, color); + + if (((y2 - y1) * ydirflag) > 0) { + while (x < xend) { + x++; + if (d < 0) { + d += incr1; + } else { + y++; + d += incr2; + } + wstart = y - wid / 2; + for (w = wstart; w < wstart + wid; w++) + gdImageSetPixel (im, x, w, color); + } + } else { + while (x < xend) { + x++; + if (d < 0) { + d += incr1; + } else { + y--; + d += incr2; + } + wstart = y - wid / 2; + for (w = wstart; w < wstart + wid; w++) + gdImageSetPixel (im, x, w, color); + } + } + } else { + /* More-or-less vertical. use wid for horizontal stroke */ + /* 2.0.12: Michael Schwartz: divide rather than multiply; + TBB: but watch out for /0! */ + double as = sin (atan2 (dy, dx)); + if (as != 0) { + wid = thick / as; + } else { + wid = 1; + } + if (wid == 0) + wid = 1; + + d = 2 * dx - dy; + incr1 = 2 * dx; + incr2 = 2 * (dx - dy); + if (y1 > y2) { + y = y2; + x = x2; + yend = y1; + xdirflag = (-1); + } else { + y = y1; + x = x1; + yend = y2; + xdirflag = 1; + } + + /* Set up line thickness */ + wstart = x - wid / 2; + for (w = wstart; w < wstart + wid; w++) + gdImageSetPixel (im, w, y, color); + + if (((x2 - x1) * xdirflag) > 0) { + while (y < yend) { + y++; + if (d < 0) { + d += incr1; + } else { + x++; + d += incr2; + } + wstart = x - wid / 2; + for (w = wstart; w < wstart + wid; w++) + gdImageSetPixel (im, w, y, color); + } + } else { + while (y < yend) { + y++; + if (d < 0) { + d += incr1; + } else { + x--; + d += incr2; + } + wstart = x - wid / 2; + for (w = wstart; w < wstart + wid; w++) + gdImageSetPixel (im, w, y, color); + } + } + } + +} +static void dashedSet (gdImagePtr im, int x, int y, int color, + int *onP, int *dashStepP, int wid, int vert); + +BGD_DECLARE(void) gdImageDashedLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color) +{ + int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag; + int dashStep = 0; + int on = 1; + int wid; + int vert; + int thick = im->thick; + + dx = abs (x2 - x1); + dy = abs (y2 - y1); + if (dy <= dx) { + /* More-or-less horizontal. use wid for vertical stroke */ + /* 2.0.12: Michael Schwartz: divide rather than multiply; + TBB: but watch out for /0! */ + double as = sin (atan2 (dy, dx)); + if (as != 0) { + wid = thick / as; + } else { + wid = 1; + } + vert = 1; + + d = 2 * dy - dx; + incr1 = 2 * dy; + incr2 = 2 * (dy - dx); + if (x1 > x2) { + x = x2; + y = y2; + ydirflag = (-1); + xend = x1; + } else { + x = x1; + y = y1; + ydirflag = 1; + xend = x2; + } + dashedSet (im, x, y, color, &on, &dashStep, wid, vert); + if (((y2 - y1) * ydirflag) > 0) { + while (x < xend) { + x++; + if (d < 0) { + d += incr1; + } else { + y++; + d += incr2; + } + dashedSet (im, x, y, color, &on, &dashStep, wid, vert); + } + } else { + while (x < xend) { + x++; + if (d < 0) { + d += incr1; + } else { + y--; + d += incr2; + } + dashedSet (im, x, y, color, &on, &dashStep, wid, vert); + } + } + } else { + /* 2.0.12: Michael Schwartz: divide rather than multiply; + TBB: but watch out for /0! */ + double as = sin (atan2 (dy, dx)); + if (as != 0) { + wid = thick / as; + } else { + wid = 1; + } + vert = 0; + + d = 2 * dx - dy; + incr1 = 2 * dx; + incr2 = 2 * (dx - dy); + if (y1 > y2) { + y = y2; + x = x2; + yend = y1; + xdirflag = (-1); + } else { + y = y1; + x = x1; + yend = y2; + xdirflag = 1; + } + dashedSet (im, x, y, color, &on, &dashStep, wid, vert); + if (((x2 - x1) * xdirflag) > 0) { + while (y < yend) { + y++; + if (d < 0) { + d += incr1; + } else { + x++; + d += incr2; + } + dashedSet (im, x, y, color, &on, &dashStep, wid, vert); + } + } else { + while (y < yend) { + y++; + if (d < 0) { + d += incr1; + } else { + x--; + d += incr2; + } + dashedSet (im, x, y, color, &on, &dashStep, wid, vert); + } + } + } +} + +static void +dashedSet (gdImagePtr im, int x, int y, int color, + int *onP, int *dashStepP, int wid, int vert) +{ + int dashStep = *dashStepP; + int on = *onP; + int w, wstart; + + dashStep++; + if (dashStep == gdDashSize) { + dashStep = 0; + on = !on; + } + if (on) { + if (vert) { + wstart = y - wid / 2; + for (w = wstart; w < wstart + wid; w++) + gdImageSetPixel (im, x, w, color); + } else { + wstart = x - wid / 2; + for (w = wstart; w < wstart + wid; w++) + gdImageSetPixel (im, w, y, color); + } + } + *dashStepP = dashStep; + *onP = on; +} + +BGD_DECLARE(int) gdImageBoundsSafe (gdImagePtr im, int x, int y) +{ + return gdImageBoundsSafeMacro (im, x, y); +} + +BGD_DECLARE(void) gdImageChar (gdImagePtr im, gdFontPtr f, int x, int y, int c, int color) +{ + int cx, cy; + int px, py; + int fline; + cx = 0; + cy = 0; +#ifdef CHARSET_EBCDIC + c = ASC (c); +#endif /*CHARSET_EBCDIC */ + if ((c < f->offset) || (c >= (f->offset + f->nchars))) { + return; + } + fline = (c - f->offset) * f->h * f->w; + for (py = y; (py < (y + f->h)); py++) { + for (px = x; (px < (x + f->w)); px++) { + if (f->data[fline + cy * f->w + cx]) { + gdImageSetPixel (im, px, py, color); + } + cx++; + } + cx = 0; + cy++; + } +} + +BGD_DECLARE(void) gdImageCharUp (gdImagePtr im, gdFontPtr f, int x, int y, int c, int color) +{ + int cx, cy; + int px, py; + int fline; + cx = 0; + cy = 0; +#ifdef CHARSET_EBCDIC + c = ASC (c); +#endif /*CHARSET_EBCDIC */ + if ((c < f->offset) || (c >= (f->offset + f->nchars))) { + return; + } + fline = (c - f->offset) * f->h * f->w; + for (py = y; (py > (y - f->w)); py--) { + for (px = x; (px < (x + f->h)); px++) { + if (f->data[fline + cy * f->w + cx]) { + gdImageSetPixel (im, px, py, color); + } + cy++; + } + cy = 0; + cx++; + } +} + +BGD_DECLARE(void) gdImageString (gdImagePtr im, gdFontPtr f, + int x, int y, unsigned char *s, int color) +{ + int i; + int l; + l = strlen ((char *) s); + for (i = 0; (i < l); i++) { + gdImageChar (im, f, x, y, s[i], color); + x += f->w; + } +} + +BGD_DECLARE(void) gdImageStringUp (gdImagePtr im, gdFontPtr f, + int x, int y, unsigned char *s, int color) +{ + int i; + int l; + l = strlen ((char *) s); + for (i = 0; (i < l); i++) { + gdImageCharUp (im, f, x, y, s[i], color); + y -= f->w; + } +} + +static int strlen16 (unsigned short *s); + +BGD_DECLARE(void) gdImageString16 (gdImagePtr im, gdFontPtr f, + int x, int y, unsigned short *s, int color) +{ + int i; + int l; + l = strlen16 (s); + for (i = 0; (i < l); i++) { + gdImageChar (im, f, x, y, s[i], color); + x += f->w; + } +} + +BGD_DECLARE(void) gdImageStringUp16 (gdImagePtr im, gdFontPtr f, + int x, int y, unsigned short *s, int color) +{ + int i; + int l; + l = strlen16 (s); + for (i = 0; (i < l); i++) { + gdImageCharUp (im, f, x, y, s[i], color); + y -= f->w; + } +} + +static int +strlen16 (unsigned short *s) +{ + int len = 0; + while (*s) { + s++; + len++; + } + return len; +} + +#ifndef HAVE_LSQRT +/* If you don't have a nice square root function for longs, you can use + ** this hack + */ +long +lsqrt (long n) +{ + long result = (long) sqrt ((double) n); + return result; +} +#endif + +/* s and e are integers modulo 360 (degrees), with 0 degrees + being the rightmost extreme and degrees changing clockwise. + cx and cy are the center in pixels; w and h are the horizontal + and vertical diameter in pixels. Nice interface, but slow. + See gd_arc_f_buggy.c for a better version that doesn't + seem to be bug-free yet. */ + +BGD_DECLARE(void) gdImageArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, + int color) +{ + gdImageFilledArc (im, cx, cy, w, h, s, e, color, gdNoFill); +} + +BGD_DECLARE(void) gdImageFilledArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, + int color, int style) +{ + gdPoint pts[3]; + int i; + int lx = 0, ly = 0; + int fx = 0, fy = 0; + + if ((s % 360) == (e % 360)) { + s = 0; + e = 360; + } else { + if (s > 360) { + s = s % 360; + } + + if (e > 360) { + e = e % 360; + } + + while (s < 0) { + s += 360; + } + + while (e < s) { + e += 360; + } + + if (s == e) { + s = 0; + e = 360; + } + } + + for (i = s; (i <= e); i++) { + int x, y; + x = ((long) gdCosT[i % 360] * (long) w / (2 * 1024)) + cx; + y = ((long) gdSinT[i % 360] * (long) h / (2 * 1024)) + cy; + if (i != s) { + if (!(style & gdChord)) { + if (style & gdNoFill) { + gdImageLine (im, lx, ly, x, y, color); + } else { + /* This is expensive! */ + pts[0].x = lx; + pts[0].y = ly; + pts[1].x = x; + pts[1].y = y; + pts[2].x = cx; + pts[2].y = cy; + gdImageFilledPolygon (im, pts, 3, color); + } + } + } else { + fx = x; + fy = y; + } + lx = x; + ly = y; + } + if (style & gdChord) { + if (style & gdNoFill) { + if (style & gdEdged) { + gdImageLine (im, cx, cy, lx, ly, color); + gdImageLine (im, cx, cy, fx, fy, color); + } + gdImageLine (im, fx, fy, lx, ly, color); + } else { + pts[0].x = fx; + pts[0].y = fy; + pts[1].x = lx; + pts[1].y = ly; + pts[2].x = cx; + pts[2].y = cy; + gdImageFilledPolygon (im, pts, 3, color); + } + } else { + if (style & gdNoFill) { + if (style & gdEdged) { + gdImageLine (im, cx, cy, lx, ly, color); + gdImageLine (im, cx, cy, fx, fy, color); + } + } + } +} + +BGD_DECLARE(void) gdImageEllipse(gdImagePtr im, int mx, int my, int w, int h, int c) +{ + int x=0,mx1=0,mx2=0,my1=0,my2=0; + long aq,bq,dx,dy,r,rx,ry,a,b; + + a=w>>1; + b=h>>1; + gdImageSetPixel(im,mx+a, my, c); + gdImageSetPixel(im,mx-a, my, c); + mx1 = mx-a; + my1 = my; + mx2 = mx+a; + my2 = my; + + aq = a * a; + bq = b * b; + dx = aq << 1; + dy = bq << 1; + r = a * bq; + rx = r << 1; + ry = 0; + x = a; + while (x > 0) { + if (r > 0) { + my1++; + my2--; + ry +=dx; + r -=ry; + } + if (r <= 0) { + x--; + mx1++; + mx2--; + rx -=dy; + r +=rx; + } + gdImageSetPixel(im,mx1, my1, c); + gdImageSetPixel(im,mx1, my2, c); + gdImageSetPixel(im,mx2, my1, c); + gdImageSetPixel(im,mx2, my2, c); + } +} + + +BGD_DECLARE(void) gdImageFilledEllipse (gdImagePtr im, int mx, int my, int w, int h, int c) +{ + int x=0,mx1=0,mx2=0,my1=0,my2=0; + long aq,bq,dx,dy,r,rx,ry,a,b; + int i; + int old_y2; + + a=w>>1; + b=h>>1; + + for (x = mx-a; x <= mx+a; x++) { + gdImageSetPixel(im, x, my, c); + } + + mx1 = mx-a; + my1 = my; + mx2 = mx+a; + my2 = my; + + aq = a * a; + bq = b * b; + dx = aq << 1; + dy = bq << 1; + r = a * bq; + rx = r << 1; + ry = 0; + x = a; + old_y2=-2; + while (x > 0) { + if (r > 0) { + my1++; + my2--; + ry +=dx; + r -=ry; + } + if (r <= 0) { + x--; + mx1++; + mx2--; + rx -=dy; + r +=rx; + } + if(old_y2!=my2) { + for(i=mx1; i<=mx2; i++) { + gdImageSetPixel(im,i,my1,c); + } + } + if(old_y2!=my2) { + for(i=mx1; i<=mx2; i++) { + gdImageSetPixel(im,i,my2,c); + } + } + old_y2 = my2; + } +} + +BGD_DECLARE(void) gdImageFillToBorder (gdImagePtr im, int x, int y, int border, int color) +{ + int lastBorder; + /* Seek left */ + int leftLimit, rightLimit; + int i; + int restoreAlphaBleding; + + if (border < 0) { + /* Refuse to fill to a non-solid border */ + return; + } + + leftLimit = (-1); + + restoreAlphaBleding = im->alphaBlendingFlag; + im->alphaBlendingFlag = 0; + + for (i = x; (i >= 0); i--) { + if (gdImageGetPixel (im, i, y) == border) { + break; + } + gdImageSetPixel (im, i, y, color); + leftLimit = i; + } + if (leftLimit == (-1)) { + im->alphaBlendingFlag = restoreAlphaBleding; + return; + } + /* Seek right */ + rightLimit = x; + for (i = (x + 1); (i < im->sx); i++) { + if (gdImageGetPixel (im, i, y) == border) { + break; + } + gdImageSetPixel (im, i, y, color); + rightLimit = i; + } + /* Look at lines above and below and start paints */ + /* Above */ + if (y > 0) { + lastBorder = 1; + for (i = leftLimit; (i <= rightLimit); i++) { + int c; + c = gdImageGetPixel (im, i, y - 1); + if (lastBorder) { + if ((c != border) && (c != color)) { + gdImageFillToBorder (im, i, y - 1, border, color); + lastBorder = 0; + } + } else if ((c == border) || (c == color)) { + lastBorder = 1; + } + } + } + /* Below */ + if (y < ((im->sy) - 1)) { + lastBorder = 1; + for (i = leftLimit; (i <= rightLimit); i++) { + int c = gdImageGetPixel (im, i, y + 1); + if (lastBorder) { + if ((c != border) && (c != color)) { + gdImageFillToBorder (im, i, y + 1, border, color); + lastBorder = 0; + } + } else if ((c == border) || (c == color)) { + lastBorder = 1; + } + } + } + im->alphaBlendingFlag = restoreAlphaBleding; +} + +/* + * set the pixel at (x,y) and its 4-connected neighbors + * with the same pixel value to the new pixel value nc (new color). + * A 4-connected neighbor: pixel above, below, left, or right of a pixel. + * ideas from comp.graphics discussions. + * For tiled fill, the use of a flag buffer is mandatory. As the tile image can + * contain the same color as the color to fill. To do not bloat normal filling + * code I added a 2nd private function. + */ + +static int gdImageTileGet (gdImagePtr im, int x, int y) +{ + int srcx, srcy; + int tileColor,p; + if (!im->tile) { + return -1; + } + srcx = x % gdImageSX(im->tile); + srcy = y % gdImageSY(im->tile); + p = gdImageGetPixel(im->tile, srcx, srcy); + if (p == im->tile->transparent) { + tileColor = im->transparent; + } else if (im->trueColor) { + if (im->tile->trueColor) { + tileColor = p; + } else { + tileColor = gdTrueColorAlpha( gdImageRed(im->tile,p), gdImageGreen(im->tile,p), gdImageBlue (im->tile,p), gdImageAlpha (im->tile,p)); + } + } else { + if (im->tile->trueColor) { + tileColor = gdImageColorResolveAlpha(im, gdTrueColorGetRed (p), gdTrueColorGetGreen (p), gdTrueColorGetBlue (p), gdTrueColorGetAlpha (p)); + } else { + tileColor = gdImageColorResolveAlpha(im, gdImageRed (im->tile,p), gdImageGreen (im->tile,p), gdImageBlue (im->tile,p), gdImageAlpha (im->tile,p)); + } + } + return tileColor; +} + + + +/* horizontal segment of scan line y */ +struct seg { + int y, xl, xr, dy; +}; + +/* max depth of stack */ +#define FILL_MAX ((int)(im->sy*im->sx)/4) +#define FILL_PUSH(Y, XL, XR, DY) \ + if (sp<stack+FILL_MAX && Y+(DY)>=0 && Y+(DY)<wy2) \ + {sp->y = Y; sp->xl = XL; sp->xr = XR; sp->dy = DY; sp++;} + +#define FILL_POP(Y, XL, XR, DY) \ + {sp--; Y = sp->y+(DY = sp->dy); XL = sp->xl; XR = sp->xr;} + +static void _gdImageFillTiled(gdImagePtr im, int x, int y, int nc); +BGD_DECLARE(void) gdImageFill(gdImagePtr im, int x, int y, int nc) +{ + int l, x1, x2, dy; + int oc; /* old pixel value */ + int wx2,wy2; + + int alphablending_bak; + + /* stack of filled segments */ + /* struct seg stack[FILL_MAX],*sp = stack;; */ + struct seg *stack; + struct seg *sp; + + if (!im->trueColor && nc > (im->colorsTotal - 1)) { + return; + } + + alphablending_bak = im->alphaBlendingFlag; + im->alphaBlendingFlag = 0; + + if (nc==gdTiled) { + _gdImageFillTiled(im,x,y,nc); + im->alphaBlendingFlag = alphablending_bak; + return; + } + + wx2=im->sx; + wy2=im->sy; + oc = gdImageGetPixel(im, x, y); + if (oc==nc || x<0 || x>wx2 || y<0 || y>wy2) { + im->alphaBlendingFlag = alphablending_bak; + return; + } + + /* Do not use the 4 neighbors implementation with + * small images + */ + if (im->sx < 4) { + int ix = x, iy = y, c; + do { + do { + c = gdImageGetPixel(im, ix, iy); + if (c != oc) { + goto done; + } + gdImageSetPixel(im, ix, iy, nc); + } while(ix++ < (im->sx -1)); + ix = x; + } while(iy++ < (im->sy -1)); + goto done; + } + + if(overflow2(im->sy, im->sx)) { + return; + } + + if(overflow2(sizeof(struct seg), ((im->sy * im->sx) / 4))) { + return; + } + + stack = (struct seg *)gdMalloc(sizeof(struct seg) * ((int)(im->sy*im->sx)/4)); + if (!stack) { + return; + } + sp = stack; + + /* required! */ + FILL_PUSH(y,x,x,1); + /* seed segment (popped 1st) */ + FILL_PUSH(y+1, x, x, -1); + while (sp>stack) { + FILL_POP(y, x1, x2, dy); + + for (x=x1; x>=0 && gdImageGetPixel(im,x, y)==oc; x--) { + gdImageSetPixel(im,x, y, nc); + } + if (x>=x1) { + goto skip; + } + l = x+1; + + /* leak on left? */ + if (l<x1) { + FILL_PUSH(y, l, x1-1, -dy); + } + x = x1+1; + do { + for (; x<=wx2 && gdImageGetPixel(im,x, y)==oc; x++) { + gdImageSetPixel(im, x, y, nc); + } + FILL_PUSH(y, l, x-1, dy); + /* leak on right? */ + if (x>x2+1) { + FILL_PUSH(y, x2+1, x-1, -dy); + } +skip: + for (x++; x<=x2 && (gdImageGetPixel(im, x, y)!=oc); x++); + + l = x; + } while (x<=x2); + } + + gdFree(stack); + +done: + im->alphaBlendingFlag = alphablending_bak; +} + +static void _gdImageFillTiled(gdImagePtr im, int x, int y, int nc) +{ + int l, x1, x2, dy; + int oc; /* old pixel value */ + int wx2,wy2; + /* stack of filled segments */ + struct seg *stack; + struct seg *sp; + char *pts; + + if (!im->tile) { + return; + } + + wx2=im->sx; + wy2=im->sy; + + if(overflow2(im->sy, im->sx)) { + return; + } + + if(overflow2(sizeof(struct seg), ((im->sy * im->sx) / 4))) { + return; + } + + pts = (char *) gdCalloc(im->sy * im->sx, sizeof(char)); + if (!pts) { + return; + } + + stack = (struct seg *)gdMalloc(sizeof(struct seg) * ((int)(im->sy*im->sx)/4)); + if (!stack) { + gdFree(pts); + return; + } + sp = stack; + + oc = gdImageGetPixel(im, x, y); + + /* required! */ + FILL_PUSH(y,x,x,1); + /* seed segment (popped 1st) */ + FILL_PUSH(y+1, x, x, -1); + while (sp>stack) { + FILL_POP(y, x1, x2, dy); + for (x=x1; x>=0 && (!pts[y + x*wx2] && gdImageGetPixel(im,x,y)==oc); x--) { + nc = gdImageTileGet(im,x,y); + pts[y + x*wx2]=1; + gdImageSetPixel(im,x, y, nc); + } + if (x>=x1) { + goto skip; + } + l = x+1; + + /* leak on left? */ + if (l<x1) { + FILL_PUSH(y, l, x1-1, -dy); + } + x = x1+1; + do { + for (; x<wx2 && (!pts[y + x*wx2] && gdImageGetPixel(im,x, y)==oc) ; x++) { + if (pts[y + x*wx2]) { + /* we should never be here */ + break; + } + nc = gdImageTileGet(im,x,y); + pts[y + x*wx2]=1; + gdImageSetPixel(im, x, y, nc); + } + FILL_PUSH(y, l, x-1, dy); + /* leak on right? */ + if (x>x2+1) { + FILL_PUSH(y, x2+1, x-1, -dy); + } +skip: + for (x++; x<=x2 && (pts[y + x*wx2] || gdImageGetPixel(im,x, y)!=oc); x++); + l = x; + } while (x<=x2); + } + + gdFree(pts); + gdFree(stack); +} + +BGD_DECLARE(void) gdImageRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color) +{ + int thick = im->thick; + + if (x1 == x2 && y1 == y2 && thick == 1) { + gdImageSetPixel(im, x1, y1, color); + return; + } + + if (y2 < y1) { + int t; + t = y1; + y1 = y2; + y2 = t; + + t = x1; + x1 = x2; + x2 = t; + } + + if (thick > 1) { + int cx, cy, x1ul, y1ul, x2lr, y2lr; + int half = thick >> 1; + x1ul = x1 - half; + y1ul = y1 - half; + + x2lr = x2 + half; + y2lr = y2 + half; + + cy = y1ul + thick; + while (cy-- > y1ul) { + cx = x1ul - 1; + while (cx++ < x2lr) { + gdImageSetPixel(im, cx, cy, color); + } + } + + cy = y2lr - thick; + while (cy++ < y2lr) { + cx = x1ul - 1; + while (cx++ < x2lr) { + gdImageSetPixel(im, cx, cy, color); + } + } + + cy = y1ul + thick - 1; + while (cy++ < y2lr -thick) { + cx = x1ul - 1; + while (cx++ < x1ul + thick) { + gdImageSetPixel(im, cx, cy, color); + } + } + + cy = y1ul + thick - 1; + while (cy++ < y2lr -thick) { + cx = x2lr - thick - 1; + while (cx++ < x2lr) { + gdImageSetPixel(im, cx, cy, color); + } + } + + return; + } else { + gdImageLine(im, x1, y1, x2, y1, color); + gdImageLine(im, x1, y2, x2, y2, color); + gdImageLine(im, x1, y1 + 1, x1, y2 - 1, color); + gdImageLine(im, x2, y1 + 1, x2, y2 - 1, color); + } +} + +BGD_DECLARE(void) gdImageFilledRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, + int color) +{ + int x, y; + + if (x1 == x2 && y1 == y2) { + gdImageSetPixel(im, x1, y1, color); + return; + } + + if (x1 > x2) { + x = x1; + x1 = x2; + x2 = x; + } + + if (y1 > y2) { + y = y1; + y1 = y2; + y2 = y; + } + + if (x1 < 0) { + x1 = 0; + } + + if (x2 >= gdImageSX(im)) { + x2 = gdImageSX(im) - 1; + } + + if (y1 < 0) { + y1 = 0; + } + + if (y2 >= gdImageSY(im)) { + y2 = gdImageSY(im) - 1; + } + + for (y = y1; (y <= y2); y++) { + for (x = x1; (x <= x2); x++) { + gdImageSetPixel (im, x, y, color); + } + } +} + +BGD_DECLARE(gdImagePtr) gdImageClone (gdImagePtr src) { + gdImagePtr dst; + register int i, x; + + if (src->trueColor) { + dst = gdImageCreateTrueColor(src->sx , src->sy); + } else { + dst = gdImageCreate(src->sx , src->sy); + } + + if (dst == NULL) { + return NULL; + } + + if (src->trueColor == 0) { + dst->colorsTotal = src->colorsTotal; + for (i = 0; i < gdMaxColors; i++) { + dst->red[i] = src->red[i]; + dst->green[i] = src->green[i]; + dst->blue[i] = src->blue[i]; + dst->alpha[i] = src->alpha[i]; + dst->open[i] = src->open[i]; + } + for (i = 0; i < src->sy; i++) { + for (x = 0; x < src->sx; x++) { + dst->pixels[i][x] = dst->pixels[i][x]; + } + } + } else { + for (i = 0; i < src->sy; i++) { + for (x = 0; x < src->sx; x++) { + dst->tpixels[i][x] = src->tpixels[i][x]; + } + } + } + + if (src->styleLength > 0) { + dst->styleLength = src->styleLength; + dst->stylePos = src->stylePos; + for (i = 0; i < src->styleLength; i++) { + dst->style[i] = src->style[i]; + } + } + + dst->interlace = src->interlace; + + dst->alphaBlendingFlag = src->alphaBlendingFlag; + dst->saveAlphaFlag = src->saveAlphaFlag; + dst->AA = src->AA; + dst->AA_color = src->AA_color; + dst->AA_dont_blend = src->AA_dont_blend; + + dst->cx1 = src->cx1; + dst->cy1 = src->cy1; + dst->cx2 = src->cx2; + dst->cy2 = src->cy2; + + dst->res_x = src->res_x; + dst->res_y = src->res_x; + + dst->paletteQuantizationMethod = src->paletteQuantizationMethod; + dst->paletteQuantizationSpeed = src->paletteQuantizationSpeed; + dst->paletteQuantizationMinQuality = src->paletteQuantizationMinQuality; + dst->paletteQuantizationMinQuality = src->paletteQuantizationMinQuality; + + dst->interpolation_id = src->interpolation_id; + dst->interpolation = src->interpolation; + + if (src->brush) { + dst->brush = gdImageClone(src->brush); + } + + if (src->tile) { + dst->tile = gdImageClone(src->tile); + } + + if (src->style) { + gdImageSetStyle(dst, src->style, src->styleLength); + } + + for (i = 0; i < gdMaxColors; i++) { + dst->brushColorMap[i] = src->brushColorMap[i]; + dst->tileColorMap[i] = src->tileColorMap[i]; + } + + if (src->polyAllocated > 0) { + dst->polyAllocated = src->polyAllocated; + for (i = 0; i < src->polyAllocated; i++) { + dst->polyInts[i] = src->polyInts[i]; + } + } + + return dst; +} + +BGD_DECLARE(void) gdImageCopy (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, + int srcY, int w, int h) +{ + int c; + int x, y; + int tox, toy; + int i; + int colorMap[gdMaxColors]; + + if (dst->trueColor) { + /* 2.0: much easier when the destination is truecolor. */ + /* 2.0.10: needs a transparent-index check that is still valid if + * * the source is not truecolor. Thanks to Frank Warmerdam. + */ + + if (src->trueColor) { + for (y = 0; (y < h); y++) { + for (x = 0; (x < w); x++) { + int c = gdImageGetTrueColorPixel (src, srcX + x, srcY + y); + if (c != src->transparent) { + gdImageSetPixel (dst, dstX + x, dstY + y, c); + } + } + } + } else { + /* source is palette based */ + for (y = 0; (y < h); y++) { + for (x = 0; (x < w); x++) { + int c = gdImageGetPixel (src, srcX + x, srcY + y); + if (c != src->transparent) { + gdImageSetPixel(dst, dstX + x, dstY + y, gdTrueColorAlpha(src->red[c], src->green[c], src->blue[c], src->alpha[c])); + } + } + } + } + return; + } + + for (i = 0; (i < gdMaxColors); i++) { + colorMap[i] = (-1); + } + toy = dstY; + for (y = srcY; (y < (srcY + h)); y++) { + tox = dstX; + for (x = srcX; (x < (srcX + w)); x++) { + int nc; + int mapTo; + c = gdImageGetPixel (src, x, y); + /* Added 7/24/95: support transparent copies */ + if (gdImageGetTransparent (src) == c) { + tox++; + continue; + } + /* Have we established a mapping for this color? */ + if (src->trueColor) { + /* 2.05: remap to the palette available in the + destination image. This is slow and + works badly, but it beats crashing! Thanks + to Padhrig McCarthy. */ + mapTo = gdImageColorResolveAlpha (dst, + gdTrueColorGetRed (c), + gdTrueColorGetGreen (c), + gdTrueColorGetBlue (c), + gdTrueColorGetAlpha (c)); + } else if (colorMap[c] == (-1)) { + /* If it's the same image, mapping is trivial */ + if (dst == src) { + nc = c; + } else { + /* Get best match possible. This + function never returns error. */ + nc = gdImageColorResolveAlpha (dst, + src->red[c], src->green[c], + src->blue[c], src->alpha[c]); + } + colorMap[c] = nc; + mapTo = colorMap[c]; + } else { + mapTo = colorMap[c]; + } + gdImageSetPixel (dst, tox, toy, mapTo); + tox++; + } + toy++; + } +} + +/* This function is a substitute for real alpha channel operations, + so it doesn't pay attention to the alpha channel. */ +BGD_DECLARE(void) gdImageCopyMerge (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, + int srcX, int srcY, int w, int h, int pct) +{ + + int c, dc; + int x, y; + int tox, toy; + int ncR, ncG, ncB; + toy = dstY; + for (y = srcY; (y < (srcY + h)); y++) { + tox = dstX; + for (x = srcX; (x < (srcX + w)); x++) { + int nc; + c = gdImageGetPixel (src, x, y); + /* Added 7/24/95: support transparent copies */ + if (gdImageGetTransparent (src) == c) { + tox++; + continue; + } + /* If it's the same image, mapping is trivial */ + if (dst == src) { + nc = c; + } else { + dc = gdImageGetPixel (dst, tox, toy); + + ncR = gdImageRed (src, c) * (pct / 100.0) + + gdImageRed (dst, dc) * ((100 - pct) / 100.0); + ncG = gdImageGreen (src, c) * (pct / 100.0) + + gdImageGreen (dst, dc) * ((100 - pct) / 100.0); + ncB = gdImageBlue (src, c) * (pct / 100.0) + + gdImageBlue (dst, dc) * ((100 - pct) / 100.0); + + /* Find a reasonable color */ + nc = gdImageColorResolve (dst, ncR, ncG, ncB); + } + gdImageSetPixel (dst, tox, toy, nc); + tox++; + } + toy++; + } +} + +/* This function is a substitute for real alpha channel operations, + so it doesn't pay attention to the alpha channel. */ +BGD_DECLARE(void) gdImageCopyMergeGray (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, + int srcX, int srcY, int w, int h, int pct) +{ + + int c, dc; + int x, y; + int tox, toy; + int ncR, ncG, ncB; + float g; + toy = dstY; + for (y = srcY; (y < (srcY + h)); y++) { + tox = dstX; + for (x = srcX; (x < (srcX + w)); x++) { + int nc; + c = gdImageGetPixel (src, x, y); + /* Added 7/24/95: support transparent copies */ + if (gdImageGetTransparent (src) == c) { + tox++; + continue; + } + /* + * If it's the same image, mapping is NOT trivial since we + * merge with greyscale target, but if pct is 100, the grey + * value is not used, so it becomes trivial. pjw 2.0.12. + */ + if (dst == src && pct == 100) { + nc = c; + } else { + dc = gdImageGetPixel (dst, tox, toy); + g = 0.29900 * gdImageRed(dst, dc) + + 0.58700 * gdImageGreen(dst, dc) + 0.11400 * gdImageBlue(dst, dc); + + ncR = gdImageRed (src, c) * (pct / 100.0) + + g * ((100 - pct) / 100.0); + ncG = gdImageGreen (src, c) * (pct / 100.0) + + g * ((100 - pct) / 100.0); + ncB = gdImageBlue (src, c) * (pct / 100.0) + + g * ((100 - pct) / 100.0); + + /* First look for an exact match */ + nc = gdImageColorExact (dst, ncR, ncG, ncB); + if (nc == (-1)) { + /* No, so try to allocate it */ + nc = gdImageColorAllocate (dst, ncR, ncG, ncB); + /* If we're out of colors, go for the + closest color */ + if (nc == (-1)) { + nc = gdImageColorClosest (dst, ncR, ncG, ncB); + } + } + } + gdImageSetPixel (dst, tox, toy, nc); + tox++; + } + toy++; + } +} + +BGD_DECLARE(void) gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, + int srcX, int srcY, int dstW, int dstH, int srcW, + int srcH) +{ + int c; + int x, y; + int tox, toy; + int ydest; + int i; + int colorMap[gdMaxColors]; + /* Stretch vectors */ + int *stx; + int *sty; + /* We only need to use floating point to determine the correct + stretch vector for one line's worth. */ + if (overflow2(sizeof (int), srcW)) { + return; + } + if (overflow2(sizeof (int), srcH)) { + return; + } + stx = (int *) gdMalloc (sizeof (int) * srcW); + if (!stx) { + return; + } + + sty = (int *) gdMalloc (sizeof (int) * srcH); + if (!sty) { + gdFree(stx); + return; + } + + /* Fixed by Mao Morimoto 2.0.16 */ + for (i = 0; (i < srcW); i++) { + stx[i] = dstW * (i + 1) / srcW - dstW * i / srcW; + } + for (i = 0; (i < srcH); i++) { + sty[i] = dstH * (i + 1) / srcH - dstH * i / srcH; + } + for (i = 0; (i < gdMaxColors); i++) { + colorMap[i] = (-1); + } + toy = dstY; + for (y = srcY; (y < (srcY + srcH)); y++) { + for (ydest = 0; (ydest < sty[y - srcY]); ydest++) { + tox = dstX; + for (x = srcX; (x < (srcX + srcW)); x++) { + int nc = 0; + int mapTo; + if (!stx[x - srcX]) { + continue; + } + if (dst->trueColor) { + /* 2.0.9: Thorben Kundinger: Maybe the source image is not + a truecolor image */ + if (!src->trueColor) { + int tmp = gdImageGetPixel (src, x, y); + mapTo = gdImageGetTrueColorPixel (src, x, y); + if (gdImageGetTransparent (src) == tmp) { + /* 2.0.21, TK: not tox++ */ + tox += stx[x - srcX]; + continue; + } + } else { + /* TK: old code follows */ + mapTo = gdImageGetTrueColorPixel (src, x, y); + /* Added 7/24/95: support transparent copies */ + if (gdImageGetTransparent (src) == mapTo) { + /* 2.0.21, TK: not tox++ */ + tox += stx[x - srcX]; + continue; + } + } + } else { + c = gdImageGetPixel (src, x, y); + /* Added 7/24/95: support transparent copies */ + if (gdImageGetTransparent (src) == c) { + tox += stx[x - srcX]; + continue; + } + if (src->trueColor) { + /* Remap to the palette available in the + destination image. This is slow and + works badly. */ + mapTo = gdImageColorResolveAlpha (dst, + gdTrueColorGetRed (c), + gdTrueColorGetGreen + (c), + gdTrueColorGetBlue + (c), + gdTrueColorGetAlpha + (c)); + } else { + /* Have we established a mapping for this color? */ + if (colorMap[c] == (-1)) { + /* If it's the same image, mapping is trivial */ + if (dst == src) { + nc = c; + } else { + /* Find or create the best match */ + /* 2.0.5: can't use gdTrueColorGetRed, etc with palette */ + nc = gdImageColorResolveAlpha (dst, + gdImageRed (src, + c), + gdImageGreen + (src, c), + gdImageBlue (src, + c), + gdImageAlpha + (src, c)); + } + colorMap[c] = nc; + } + mapTo = colorMap[c]; + } + } + for (i = 0; (i < stx[x - srcX]); i++) { + gdImageSetPixel (dst, tox, toy, mapTo); + tox++; + } + } + toy++; + } + } + gdFree (stx); + gdFree (sty); +} + +/* gd 2.0.8: gdImageCopyRotated is added. Source + is a rectangle, with its upper left corner at + srcX and srcY. Destination is the *center* of + the rotated copy. Angle is in degrees, same as + gdImageArc. Floating point destination center + coordinates allow accurate rotation of + objects of odd-numbered width or height. */ + +BGD_DECLARE(void) gdImageCopyRotated (gdImagePtr dst, + gdImagePtr src, + double dstX, double dstY, + int srcX, int srcY, + int srcWidth, int srcHeight, int angle) +{ + double dx, dy; + double radius = sqrt (srcWidth * srcWidth + srcHeight * srcHeight); + double aCos = cos (angle * .0174532925); + double aSin = sin (angle * .0174532925); + double scX = srcX + ((double) srcWidth) / 2; + double scY = srcY + ((double) srcHeight) / 2; + int cmap[gdMaxColors]; + int i; + + /* + 2.0.34: transparency preservation. The transparentness of + the transparent color is more important than its hue. + */ + if (src->transparent != -1) { + if (dst->transparent == -1) { + dst->transparent = src->transparent; + } + } + + for (i = 0; (i < gdMaxColors); i++) { + cmap[i] = (-1); + } + for (dy = dstY - radius; (dy <= dstY + radius); dy++) { + for (dx = dstX - radius; (dx <= dstX + radius); dx++) { + double sxd = (dx - dstX) * aCos - (dy - dstY) * aSin; + double syd = (dy - dstY) * aCos + (dx - dstX) * aSin; + int sx = sxd + scX; + int sy = syd + scY; + if ((sx >= srcX) && (sx < srcX + srcWidth) && + (sy >= srcY) && (sy < srcY + srcHeight)) { + int c = gdImageGetPixel (src, sx, sy); + /* 2.0.34: transparency wins */ + if (c == src->transparent) { + gdImageSetPixel (dst, dx, dy, dst->transparent); + } else if (!src->trueColor) { + /* Use a table to avoid an expensive + lookup on every single pixel */ + if (cmap[c] == -1) { + cmap[c] = gdImageColorResolveAlpha (dst, + gdImageRed (src, c), + gdImageGreen (src, + c), + gdImageBlue (src, + c), + gdImageAlpha (src, + c)); + } + gdImageSetPixel (dst, dx, dy, cmap[c]); + } else { + gdImageSetPixel (dst, + dx, dy, + gdImageColorResolveAlpha (dst, + gdImageRed (src, + c), + gdImageGreen + (src, c), + gdImageBlue (src, + c), + gdImageAlpha + (src, c))); + } + } + } + } +} + +/* When gd 1.x was first created, floating point was to be avoided. + These days it is often faster than table lookups or integer + arithmetic. The routine below is shamelessly, gloriously + floating point. TBB */ + +/* 2.0.10: cast instead of floor() yields 35% performance improvement. + Thanks to John Buckman. */ + +#define floor2(exp) ((long) exp) +/*#define floor2(exp) floor(exp)*/ + +BGD_DECLARE(void) gdImageCopyResampled (gdImagePtr dst, + gdImagePtr src, + int dstX, int dstY, + int srcX, int srcY, + int dstW, int dstH, int srcW, int srcH) +{ + int x, y; + double sy1, sy2, sx1, sx2; + if (!dst->trueColor) { + gdImageCopyResized (dst, src, dstX, dstY, srcX, srcY, dstW, dstH, + srcW, srcH); + return; + } + for (y = dstY; (y < dstY + dstH); y++) { + sy1 = ((double) y - (double) dstY) * (double) srcH / (double) dstH; + sy2 = ((double) (y + 1) - (double) dstY) * (double) srcH / + (double) dstH; + for (x = dstX; (x < dstX + dstW); x++) { + double sx, sy; + double spixels = 0; + double red = 0.0, green = 0.0, blue = 0.0, alpha = 0.0; + double alpha_sum = 0.0, contrib_sum = 0.0; + + sx1 = ((double) x - (double) dstX) * (double) srcW / dstW; + sx2 = ((double) (x + 1) - (double) dstX) * (double) srcW / dstW; + sy = sy1; + do { + double yportion; + if (floor2 (sy) == floor2 (sy1)) { + yportion = 1.0 - (sy - floor2 (sy)); + if (yportion > sy2 - sy1) { + yportion = sy2 - sy1; + } + sy = floor2 (sy); + } else if (sy == floor2 (sy2)) { + yportion = sy2 - floor2 (sy2); + } else { + yportion = 1.0; + } + sx = sx1; + do { + double xportion; + double pcontribution; + int p; + if (floor2 (sx) == floor2 (sx1)) { + xportion = 1.0 - (sx - floor2 (sx)); + if (xportion > sx2 - sx1) { + xportion = sx2 - sx1; + } + sx = floor2 (sx); + } else if (sx == floor2 (sx2)) { + xportion = sx2 - floor2 (sx2); + } else { + xportion = 1.0; + } + pcontribution = xportion * yportion; + /* 2.08: previously srcX and srcY were ignored. + Andrew Pattison */ + p = gdImageGetTrueColorPixel (src, + (int) sx + srcX, + (int) sy + srcY); + red += gdTrueColorGetRed (p) * pcontribution; + green += gdTrueColorGetGreen (p) * pcontribution; + blue += gdTrueColorGetBlue (p) * pcontribution; + alpha += gdTrueColorGetAlpha (p) * pcontribution; + spixels += xportion * yportion; + sx += 1.0; + } while (sx < sx2); + sy += 1.0; + } while (sy < sy2); + if (spixels != 0.0) { + red /= spixels; + green /= spixels; + blue /= spixels; + alpha /= spixels; + alpha += 0.5; + } + if ( alpha_sum != 0.0f) { + if( contrib_sum != 0.0f) { + alpha_sum /= contrib_sum; + } + red /= alpha_sum; + green /= alpha_sum; + blue /= alpha_sum; + } + /* Clamping to allow for rounding errors above */ + if (red > 255.0) { + red = 255.0; + } + if (green > 255.0) { + green = 255.0; + } + if (blue > 255.0) { + blue = 255.0; + } + if (alpha > gdAlphaMax) { + alpha = gdAlphaMax; + } + gdImageSetPixel (dst, + x, y, + gdTrueColorAlpha ((int) red, + (int) green, + (int) blue, (int) alpha)); + } + } +} + +BGD_DECLARE(void) gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c) +{ + if (n <= 0) { + return; + } + + + gdImageLine (im, p->x, p->y, p[n - 1].x, p[n - 1].y, c); + gdImageOpenPolygon (im, p, n, c); +} + +BGD_DECLARE(void) gdImageOpenPolygon (gdImagePtr im, gdPointPtr p, int n, int c) +{ + int i; + int lx, ly; + if (n <= 0) { + return; + } + + + lx = p->x; + ly = p->y; + for (i = 1; (i < n); i++) { + p++; + gdImageLine (im, lx, ly, p->x, p->y, c); + lx = p->x; + ly = p->y; + } + +} + +/* THANKS to Kirsten Schulz for the polygon fixes! */ + +/* The intersection finding technique of this code could be improved */ +/* by remembering the previous intertersection, and by using the slope. */ +/* That could help to adjust intersections to produce a nice */ +/* interior_extrema. */ + +BGD_DECLARE(void) gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c) +{ + int i; + int j; + int index; + int y; + int miny, maxy, pmaxy; + int x1, y1; + int x2, y2; + int ind1, ind2; + int ints; + int fill_color; + if (n <= 0) { + return; + } + + if (c == gdAntiAliased) { + fill_color = im->AA_color; + } else { + fill_color = c; + } + if (!im->polyAllocated) { + if (overflow2(sizeof (int), n)) { + return; + } + im->polyInts = (int *) gdMalloc (sizeof (int) * n); + if (!im->polyInts) { + return; + } + im->polyAllocated = n; + } + if (im->polyAllocated < n) { + while (im->polyAllocated < n) { + im->polyAllocated *= 2; + } + if (overflow2(sizeof (int), im->polyAllocated)) { + return; + } + im->polyInts = (int *) gdReallocEx (im->polyInts, + sizeof (int) * im->polyAllocated); + if (!im->polyInts) { + return; + } + } + miny = p[0].y; + maxy = p[0].y; + for (i = 1; (i < n); i++) { + if (p[i].y < miny) { + miny = p[i].y; + } + if (p[i].y > maxy) { + maxy = p[i].y; + } + } + pmaxy = maxy; + /* 2.0.16: Optimization by Ilia Chipitsine -- don't waste time offscreen */ + /* 2.0.26: clipping rectangle is even better */ + if (miny < im->cy1) { + miny = im->cy1; + } + if (maxy > im->cy2) { + maxy = im->cy2; + } + /* Fix in 1.3: count a vertex only once */ + for (y = miny; (y <= maxy); y++) { + ints = 0; + for (i = 0; (i < n); i++) { + if (!i) { + ind1 = n - 1; + ind2 = 0; + } else { + ind1 = i - 1; + ind2 = i; + } + y1 = p[ind1].y; + y2 = p[ind2].y; + if (y1 < y2) { + x1 = p[ind1].x; + x2 = p[ind2].x; + } else if (y1 > y2) { + y2 = p[ind1].y; + y1 = p[ind2].y; + x2 = p[ind1].x; + x1 = p[ind2].x; + } else { + continue; + } + + /* Do the following math as float intermediately, and round to ensure + * that Polygon and FilledPolygon for the same set of points have the + * same footprint. */ + + if ((y >= y1) && (y < y2)) { + im->polyInts[ints++] = (int) ((float) ((y - y1) * (x2 - x1)) / + (float) (y2 - y1) + 0.5 + x1); + } else if ((y == pmaxy) && (y == y2)) { + im->polyInts[ints++] = x2; + } + } + /* + 2.0.26: polygons pretty much always have less than 100 points, + and most of the time they have considerably less. For such trivial + cases, insertion sort is a good choice. Also a good choice for + future implementations that may wish to indirect through a table. + */ + for (i = 1; (i < ints); i++) { + index = im->polyInts[i]; + j = i; + while ((j > 0) && (im->polyInts[j - 1] > index)) { + im->polyInts[j] = im->polyInts[j - 1]; + j--; + } + im->polyInts[j] = index; + } + for (i = 0; (i < (ints-1)); i += 2) { + /* 2.0.29: back to gdImageLine to prevent segfaults when + performing a pattern fill */ + gdImageLine (im, im->polyInts[i], y, im->polyInts[i + 1], y, + fill_color); + } + } + /* If we are drawing this AA, then redraw the border with AA lines. */ + /* This doesn't work as well as I'd like, but it doesn't clash either. */ + if (c == gdAntiAliased) { + gdImagePolygon (im, p, n, c); + } +} + +static void gdImageSetAAPixelColor(gdImagePtr im, int x, int y, int color, int t); + +BGD_DECLARE(void) gdImageSetStyle (gdImagePtr im, int *style, int noOfPixels) +{ + if (im->style) { + gdFree (im->style); + } + if (overflow2(sizeof (int), noOfPixels)) { + return; + } + im->style = (int *) gdMalloc (sizeof (int) * noOfPixels); + if (!im->style) { + return; + } + memcpy (im->style, style, sizeof (int) * noOfPixels); + im->styleLength = noOfPixels; + im->stylePos = 0; +} + +BGD_DECLARE(void) gdImageSetThickness (gdImagePtr im, int thickness) +{ + im->thick = thickness; +} + +BGD_DECLARE(void) gdImageSetBrush (gdImagePtr im, gdImagePtr brush) +{ + int i; + im->brush = brush; + if ((!im->trueColor) && (!im->brush->trueColor)) { + for (i = 0; (i < gdImageColorsTotal (brush)); i++) { + int index; + index = gdImageColorResolveAlpha (im, + gdImageRed (brush, i), + gdImageGreen (brush, i), + gdImageBlue (brush, i), + gdImageAlpha (brush, i)); + im->brushColorMap[i] = index; + } + } +} + +BGD_DECLARE(void) gdImageSetTile (gdImagePtr im, gdImagePtr tile) +{ + int i; + im->tile = tile; + if ((!im->trueColor) && (!im->tile->trueColor)) { + for (i = 0; (i < gdImageColorsTotal (tile)); i++) { + int index; + index = gdImageColorResolveAlpha (im, + gdImageRed (tile, i), + gdImageGreen (tile, i), + gdImageBlue (tile, i), + gdImageAlpha (tile, i)); + im->tileColorMap[i] = index; + } + } +} + +BGD_DECLARE(void) gdImageSetAntiAliased (gdImagePtr im, int c) +{ + im->AA = 1; + im->AA_color = c; + im->AA_dont_blend = -1; +} + +BGD_DECLARE(void) gdImageSetAntiAliasedDontBlend (gdImagePtr im, int c, int dont_blend) +{ + im->AA = 1; + im->AA_color = c; + im->AA_dont_blend = dont_blend; +} + +BGD_DECLARE(void) gdImageInterlace (gdImagePtr im, int interlaceArg) +{ + im->interlace = interlaceArg; +} + +BGD_DECLARE(int) gdImageCompare (gdImagePtr im1, gdImagePtr im2) +{ + int x, y; + int p1, p2; + int cmpStatus = 0; + int sx, sy; + + if (im1->interlace != im2->interlace) { + cmpStatus |= GD_CMP_INTERLACE; + } + + if (im1->transparent != im2->transparent) { + cmpStatus |= GD_CMP_TRANSPARENT; + } + + if (im1->trueColor != im2->trueColor) { + cmpStatus |= GD_CMP_TRUECOLOR; + } + + sx = im1->sx; + if (im1->sx != im2->sx) { + cmpStatus |= GD_CMP_SIZE_X + GD_CMP_IMAGE; + if (im2->sx < im1->sx) { + sx = im2->sx; + } + } + + sy = im1->sy; + if (im1->sy != im2->sy) { + cmpStatus |= GD_CMP_SIZE_Y + GD_CMP_IMAGE; + if (im2->sy < im1->sy) { + sy = im2->sy; + } + } + + if (im1->colorsTotal != im2->colorsTotal) { + cmpStatus |= GD_CMP_NUM_COLORS; + } + + for (y = 0; (y < sy); y++) { + for (x = 0; (x < sx); x++) { + p1 = + im1->trueColor ? gdImageTrueColorPixel (im1, x, + y) : + gdImagePalettePixel (im1, x, y); + p2 = + im2->trueColor ? gdImageTrueColorPixel (im2, x, + y) : + gdImagePalettePixel (im2, x, y); + if (gdImageRed (im1, p1) != gdImageRed (im2, p2)) { + cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE; + break; + } + if (gdImageGreen (im1, p1) != gdImageGreen (im2, p2)) { + cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE; + break; + } + if (gdImageBlue (im1, p1) != gdImageBlue (im2, p2)) { + cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE; + break; + } +#if 0 + /* Soon we'll add alpha channel to palettes */ + if (gdImageAlpha (im1, p1) != gdImageAlpha (im2, p2)) { + cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE; + break; + } +#endif + } + if (cmpStatus & GD_CMP_COLOR) { + break; + }; + } + + return cmpStatus; +} + + +/* Thanks to Frank Warmerdam for this superior implementation + of gdAlphaBlend(), which merges alpha in the + destination color much better. */ + +BGD_DECLARE(int) gdAlphaBlend (int dst, int src) +{ + int src_alpha = gdTrueColorGetAlpha(src); + int dst_alpha, alpha, red, green, blue; + int src_weight, dst_weight, tot_weight; + + /* -------------------------------------------------------------------- */ + /* Simple cases we want to handle fast. */ + /* -------------------------------------------------------------------- */ + if( src_alpha == gdAlphaOpaque ) + return src; + + dst_alpha = gdTrueColorGetAlpha(dst); + if( src_alpha == gdAlphaTransparent ) + return dst; + if( dst_alpha == gdAlphaTransparent ) + return src; + + /* -------------------------------------------------------------------- */ + /* What will the source and destination alphas be? Note that */ + /* the destination weighting is substantially reduced as the */ + /* overlay becomes quite opaque. */ + /* -------------------------------------------------------------------- */ + src_weight = gdAlphaTransparent - src_alpha; + dst_weight = (gdAlphaTransparent - dst_alpha) * src_alpha / gdAlphaMax; + tot_weight = src_weight + dst_weight; + + /* -------------------------------------------------------------------- */ + /* What red, green and blue result values will we use? */ + /* -------------------------------------------------------------------- */ + alpha = src_alpha * dst_alpha / gdAlphaMax; + + red = (gdTrueColorGetRed(src) * src_weight + + gdTrueColorGetRed(dst) * dst_weight) / tot_weight; + green = (gdTrueColorGetGreen(src) * src_weight + + gdTrueColorGetGreen(dst) * dst_weight) / tot_weight; + blue = (gdTrueColorGetBlue(src) * src_weight + + gdTrueColorGetBlue(dst) * dst_weight) / tot_weight; + + /* -------------------------------------------------------------------- */ + /* Return merged result. */ + /* -------------------------------------------------------------------- */ + return ((alpha << 24) + (red << 16) + (green << 8) + blue); +} + +static int gdAlphaOverlayColor (int src, int dst, int max ); +BGD_DECLARE(int) gdLayerOverlay (int dst, int src) +{ + int a1, a2; + a1 = gdAlphaMax - gdTrueColorGetAlpha(dst); + a2 = gdAlphaMax - gdTrueColorGetAlpha(src); + return ( ((gdAlphaMax - a1*a2/gdAlphaMax) << 24) + + (gdAlphaOverlayColor( gdTrueColorGetRed(src), gdTrueColorGetRed(dst), gdRedMax ) << 16) + + (gdAlphaOverlayColor( gdTrueColorGetGreen(src), gdTrueColorGetGreen(dst), gdGreenMax ) << 8) + + (gdAlphaOverlayColor( gdTrueColorGetBlue(src), gdTrueColorGetBlue(dst), gdBlueMax )) + ); +} + +/* Apply 'overlay' effect - background pixels are colourised by the foreground colour */ +static int gdAlphaOverlayColor (int src, int dst, int max ) +{ + dst = dst << 1; + if( dst > max ) { + /* in the "light" zone */ + return dst + (src << 1) - (dst * src / max) - max; + } else { + /* in the "dark" zone */ + return dst * src / max; + } +} + +/* Apply 'multiply' effect */ +BGD_DECLARE(int) gdLayerMultiply (int dst, int src) +{ + int a1, a2, r1, r2, g1, g2, b1, b2; + a1 = gdAlphaMax - gdTrueColorGetAlpha(src); + a2 = gdAlphaMax - gdTrueColorGetAlpha(dst); + + r1 = gdRedMax - (a1 * (gdRedMax - gdTrueColorGetRed(src))) / gdAlphaMax; + r2 = gdRedMax - (a2 * (gdRedMax - gdTrueColorGetRed(dst))) / gdAlphaMax; + g1 = gdGreenMax - (a1 * (gdGreenMax - gdTrueColorGetGreen(src))) / gdAlphaMax; + g2 = gdGreenMax - (a2 * (gdGreenMax - gdTrueColorGetGreen(dst))) / gdAlphaMax; + b1 = gdBlueMax - (a1 * (gdBlueMax - gdTrueColorGetBlue(src))) / gdAlphaMax; + b2 = gdBlueMax - (a2 * (gdBlueMax - gdTrueColorGetBlue(dst))) / gdAlphaMax ; + + a1 = gdAlphaMax - a1; + a2 = gdAlphaMax - a2; + return ( ((a1*a2/gdAlphaMax) << 24) + + ((r1*r2/gdRedMax) << 16) + + ((g1*g2/gdGreenMax) << 8) + + ((b1*b2/gdBlueMax)) + ); +} + +BGD_DECLARE(void) gdImageAlphaBlending (gdImagePtr im, int alphaBlendingArg) +{ + im->alphaBlendingFlag = alphaBlendingArg; +} + +BGD_DECLARE(void) gdImageSaveAlpha (gdImagePtr im, int saveAlphaArg) +{ + im->saveAlphaFlag = saveAlphaArg; +} + +BGD_DECLARE(void) gdImageSetClip (gdImagePtr im, int x1, int y1, int x2, int y2) +{ + if (x1 < 0) { + x1 = 0; + } + if (x1 >= im->sx) { + x1 = im->sx - 1; + } + if (x2 < 0) { + x2 = 0; + } + if (x2 >= im->sx) { + x2 = im->sx - 1; + } + if (y1 < 0) { + y1 = 0; + } + if (y1 >= im->sy) { + y1 = im->sy - 1; + } + if (y2 < 0) { + y2 = 0; + } + if (y2 >= im->sy) { + y2 = im->sy - 1; + } + im->cx1 = x1; + im->cy1 = y1; + im->cx2 = x2; + im->cy2 = y2; +} + +BGD_DECLARE(void) gdImageGetClip (gdImagePtr im, int *x1P, int *y1P, int *x2P, int *y2P) +{ + *x1P = im->cx1; + *y1P = im->cy1; + *x2P = im->cx2; + *y2P = im->cy2; +} + +BGD_DECLARE(void) gdImageSetResolution(gdImagePtr im, const unsigned int res_x, const unsigned int res_y) +{ + if (res_x > 0) im->res_x = res_x; + if (res_y > 0) im->res_y = res_y; +} + +/* + * Added on 2003/12 by Pierre-Alain Joye (pajoye@pearfr.org) + * */ +#define BLEND_COLOR(a, nc, c, cc) \ +nc = (cc) + (((((c) - (cc)) * (a)) + ((((c) - (cc)) * (a)) >> 8) + 0x80) >> 8); + +static void gdImageSetAAPixelColor(gdImagePtr im, int x, int y, int color, int t) +{ + int dr,dg,db,p,r,g,b; + + /* 2.0.34: watch out for out of range calls */ + if (!gdImageBoundsSafeMacro(im, x, y)) { + return; + } + p = gdImageGetPixel(im,x,y); + /* TBB: we have to implement the dont_blend stuff to provide + the full feature set of the old implementation */ + if ((p == color) + || ((p == im->AA_dont_blend) + && (t != 0x00))) { + return; + } + dr = gdTrueColorGetRed(color); + dg = gdTrueColorGetGreen(color); + db = gdTrueColorGetBlue(color); + + r = gdTrueColorGetRed(p); + g = gdTrueColorGetGreen(p); + b = gdTrueColorGetBlue(p); + + BLEND_COLOR(t, dr, r, dr); + BLEND_COLOR(t, dg, g, dg); + BLEND_COLOR(t, db, b, db); + im->tpixels[y][x] = gdTrueColorAlpha(dr, dg, db, gdAlphaOpaque); +} + +static void gdImageAALine (gdImagePtr im, int x1, int y1, int x2, int y2, int col) +{ + /* keep them as 32bits */ + long x, y, inc, frac; + long dx, dy,tmp; + int w, wid, wstart; + int thick = im->thick; + + if (!im->trueColor) { + /* TBB: don't crash when the image is of the wrong type */ + gdImageLine(im, x1, y1, x2, y2, col); + return; + } + + /* TBB: use the clipping rectangle */ + if (clip_1d (&x1, &y1, &x2, &y2, im->cx1, im->cx2) == 0) + return; + if (clip_1d (&y1, &x1, &y2, &x2, im->cy1, im->cy2) == 0) + return; + + dx = x2 - x1; + dy = y2 - y1; + + if (dx == 0 && dy == 0) { + /* TBB: allow setting points */ + gdImageSetAAPixelColor(im, x1, y1, col, 0xFF); + return; + } else { + double ag; + ag = (abs(dy) < abs(dx)) ? cos(atan2(dy, dx)) : sin(atan2(dy, dx)); + if (ag != 0) { + wid = abs(thick / ag); + } else { + wid = 1; + } + if (wid == 0) { + wid = 1; + } + } + + /* Axis aligned lines */ + if (dx == 0) { + gdImageVLine(im, x1, y1, y2, col); + return; + } else if (dy == 0) { + gdImageHLine(im, y1, x1, x2, col); + return; + } + + if (abs(dx) > abs(dy)) { + if (dx < 0) { + tmp = x1; + x1 = x2; + x2 = tmp; + tmp = y1; + y1 = y2; + y2 = tmp; + dx = x2 - x1; + dy = y2 - y1; + } + y = y1; + inc = (dy * 65536) / dx; + frac = 0; + /* TBB: set the last pixel for consistency (<=) */ + for (x = x1 ; x <= x2 ; x++) { + wstart = y - wid / 2; + for (w = wstart; w < wstart + wid; w++) { + gdImageSetAAPixelColor(im, x , w , col , (frac >> 8) & 0xFF); + gdImageSetAAPixelColor(im, x , w + 1 , col, (~frac >> 8) & 0xFF); + } + frac += inc; + if (frac >= 65536) { + frac -= 65536; + y++; + } else if (frac < 0) { + frac += 65536; + y--; + } + } + } else { + if (dy < 0) { + tmp = x1; + x1 = x2; + x2 = tmp; + tmp = y1; + y1 = y2; + y2 = tmp; + dx = x2 - x1; + dy = y2 - y1; + } + x = x1; + inc = (dx * 65536) / dy; + frac = 0; + /* TBB: set the last pixel for consistency (<=) */ + for (y = y1 ; y <= y2 ; y++) { + wstart = x - wid / 2; + for (w = wstart; w < wstart + wid; w++) { + gdImageSetAAPixelColor(im, w , y , col, (frac >> 8) & 0xFF); + gdImageSetAAPixelColor(im, w + 1, y, col, (~frac >> 8) & 0xFF); + } + frac += inc; + if (frac >= 65536) { + frac -= 65536; + x++; + } else if (frac < 0) { + frac += 65536; + x--; + } + } + } +} + + +/* convert a palette image to true color */ +BGD_DECLARE(int) gdImagePaletteToTrueColor(gdImagePtr src) +{ + unsigned int y; + unsigned int yy; + + if (src == NULL) { + return 0; + } + + if (src->trueColor == 1) { + return 1; + } else { + unsigned int x; + const unsigned int sy = gdImageSY(src); + const unsigned int sx = gdImageSX(src); + + src->tpixels = (int **) gdMalloc(sizeof(int *) * sy); + if (src->tpixels == NULL) { + return 0; + } + + for (y = 0; y < sy; y++) { + const unsigned char *src_row = src->pixels[y]; + int * dst_row; + + /* no need to calloc it, we overwrite all pxl anyway */ + src->tpixels[y] = (int *) gdMalloc(sx * sizeof(int)); + if (src->tpixels[y] == NULL) { + goto clean_on_error; + } + + dst_row = src->tpixels[y]; + for (x = 0; x < sx; x++) { + const unsigned char c = *(src_row + x); + if (c == src->transparent) { + *(dst_row + x) = gdTrueColorAlpha(0, 0, 0, 127);; + } else { + *(dst_row + x) = gdTrueColorAlpha(src->red[c], src->green[c], src->blue[c], src->alpha[c]); + } + } + } + } + + /* free old palette buffer (y is sy) */ + for (yy = 0; yy < y; yy++) { + gdFree(src->pixels[yy]); + } + gdFree(src->pixels); + src->trueColor = 1; + src->pixels = NULL; + src->alphaBlendingFlag = 0; + src->saveAlphaFlag = 1; + return 1; + +clean_on_error: + /* free new true color buffer (y is not allocated, have failed) */ + for (yy = 0; yy < y; yy++) { + gdFree(src->tpixels[yy]); + } + gdFree(src->tpixels); + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd.h b/Build/source/libs/gd/libgd-2.1.1/src/gd.h new file mode 100644 index 00000000000..bdc479c9275 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd.h @@ -0,0 +1,1312 @@ +#ifdef __cplusplus +extern "C" { +#endif + + +#ifndef GD_H +#define GD_H 1 + +/* Version information. This gets parsed by build scripts as well as + * gcc so each #define line in this group must also be splittable on + * whitespace, take the form GD_*_VERSION and contain the magical + * trailing comment. */ +#define GD_MAJOR_VERSION 2 /*version605b5d1778*/ +#define GD_MINOR_VERSION 1 /*version605b5d1778*/ +#define GD_RELEASE_VERSION 1 /*version605b5d1778*/ +#define GD_EXTRA_VERSION "" /*version605b5d1778*/ +/* End parsable section. */ + +/* The version string. This is constructed from the version number + * parts above via macro abuse^Wtrickery. */ +#define GDXXX_VERSION_STR(mjr, mnr, rev, ext) mjr "." mnr "." rev ext +#define GDXXX_STR(s) GDXXX_SSTR(s) /* Two levels needed to expand args. */ +#define GDXXX_SSTR(s) #s + +#define GD_VERSION_STRING \ + GDXXX_VERSION_STR(GDXXX_STR(GD_MAJOR_VERSION), \ + GDXXX_STR(GD_MINOR_VERSION), \ + GDXXX_STR(GD_RELEASE_VERSION), \ + GD_EXTRA_VERSION) + + +/* Do the DLL dance: dllexport when building the DLL, + dllimport when importing from it, nothing when + not on Silly Silly Windows (tm Aardman Productions). */ + +/* 2.0.20: for headers */ + +/* 2.0.24: __stdcall also needed for Visual BASIC + and other languages. This breaks ABI compatibility + with previous DLL revs, but it's necessary. */ + +/* 2.0.29: WIN32 programmers can declare the NONDLL macro if they + wish to build gd as a static library or by directly including + the gd sources in a project. */ + +/* http://gcc.gnu.org/wiki/Visibility */ +#if defined(_WIN32) || defined(CYGWIN) || defined(_WIN32_WCE) +# ifdef BGDWIN32 +# ifdef NONDLL +# define BGD_EXPORT_DATA_PROT +# else +# ifdef __GNUC__ +# define BGD_EXPORT_DATA_PROT __attribute__ ((dllexport)) +# else +# define BGD_EXPORT_DATA_PROT __declspec(dllexport) +# endif +# endif +# else +# ifdef __GNUC__ +# define BGD_EXPORT_DATA_PROT __attribute__ ((dllimport)) +# else +# define BGD_EXPORT_DATA_PROT __declspec(dllimport) +# endif +# endif +# define BGD_STDCALL +# define BGD_EXPORT_DATA_IMPL +#else +# ifdef HAVE_VISIBILITY +# define BGD_EXPORT_DATA_PROT __attribute__ ((visibility ("default"))) +# define BGD_EXPORT_DATA_IMPL __attribute__ ((visibility ("hidden"))) +# else +# define BGD_EXPORT_DATA_PROT +# define BGD_EXPORT_DATA_IMPL +# endif +# define BGD_STDCALL +#endif + +#define BGD_DECLARE(rt) BGD_EXPORT_DATA_PROT rt BGD_STDCALL + +/* VS2012+ disable keyword macroizing unless _ALLOW_KEYWORD_MACROS is set + We define inline, snprintf, and strcasecmp if they're missing +*/ +#ifdef _MSC_VER +# define _ALLOW_KEYWORD_MACROS +# ifndef inline +# define inline __inline +# endif +# ifndef strcasecmp +# define strcasecmp _stricmp +# endif +# ifndef snprintf +# define snprintf _snprintf +# endif +#endif + +#ifdef __cplusplus + extern "C" + { +#endif + +/* gd.h: declarations file for the graphic-draw module. + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. This software is provided "AS IS." Thomas Boutell and + * Boutell.Com, Inc. disclaim all warranties, either express or implied, + * including but not limited to implied warranties of merchantability and + * fitness for a particular purpose, with respect to this code and accompanying + * documentation. */ + +/* stdio is needed for file I/O. */ +#include <stdio.h> +#include <stdarg.h> +#include "gd_io.h" + +/* The maximum number of palette entries in palette-based images. + In the wonderful new world of gd 2.0, you can of course have + many more colors when using truecolor mode. */ + +#define gdMaxColors 256 + +/* Image type. See functions below; you will not need to change + the elements directly. Use the provided macros to + access sx, sy, the color table, and colorsTotal for + read-only purposes. */ + +/* If 'truecolor' is set true, the image is truecolor; + pixels are represented by integers, which + must be 32 bits wide or more. + + True colors are repsented as follows: + + ARGB + + Where 'A' (alpha channel) occupies only the + LOWER 7 BITS of the MSB. This very small + loss of alpha channel resolution allows gd 2.x + to keep backwards compatibility by allowing + signed integers to be used to represent colors, + and negative numbers to represent special cases, + just as in gd 1.x. */ + +#define gdAlphaMax 127 +#define gdAlphaOpaque 0 +#define gdAlphaTransparent 127 +#define gdRedMax 255 +#define gdGreenMax 255 +#define gdBlueMax 255 +#define gdTrueColorGetAlpha(c) (((c) & 0x7F000000) >> 24) +#define gdTrueColorGetRed(c) (((c) & 0xFF0000) >> 16) +#define gdTrueColorGetGreen(c) (((c) & 0x00FF00) >> 8) +#define gdTrueColorGetBlue(c) ((c) & 0x0000FF) +#define gdEffectReplace 0 +#define gdEffectAlphaBlend 1 +#define gdEffectNormal 2 +#define gdEffectOverlay 3 +#define gdEffectMultiply 4 + +#define GD_TRUE 1 +#define GD_FALSE 0 + +#define GD_EPSILON 1e-6 +#ifndef M_PI +# define M_PI 3.14159265358979323846 +#endif + +/* This function accepts truecolor pixel values only. The + source color is composited with the destination color + based on the alpha channel value of the source color. + The resulting color is opaque. */ + +BGD_DECLARE(int) gdAlphaBlend (int dest, int src); +BGD_DECLARE(int) gdLayerOverlay (int dest, int src); +BGD_DECLARE(int) gdLayerMultiply (int dest, int src); + +enum gdPaletteQuantizationMethod { + GD_QUANT_DEFAULT = 0, + GD_QUANT_JQUANT = 1, /* libjpeg's old median cut. Fast, but only uses 16-bit color. */ + GD_QUANT_NEUQUANT = 2, /* neuquant - approximation using kohonen neural network. */ + GD_QUANT_LIQ = 3 /* combination of algorithms used in libimagequant/pngquant2 aiming for highest quality at cost of speed */ +}; + +/** + * Group: Transform + * + * Constants: gdInterpolationMethod + * + * GD_BELL - Bell + * GD_BESSEL - Bessel + * GD_BILINEAR_FIXED - fixed point bilinear + * GD_BICUBIC - Bicubic + * GD_BICUBIC_FIXED - fixed point bicubic integer + * GD_BLACKMAN - Blackman + * GD_BOX - Box + * GD_BSPLINE - BSpline + * GD_CATMULLROM - Catmullrom + * GD_GAUSSIAN - Gaussian + * GD_GENERALIZED_CUBIC - Generalized cubic + * GD_HERMITE - Hermite + * GD_HAMMING - Hamming + * GD_HANNING - Hannig + * GD_MITCHELL - Mitchell + * GD_NEAREST_NEIGHBOUR - Nearest neighbour interpolation + * GD_POWER - Power + * GD_QUADRATIC - Quadratic + * GD_SINC - Sinc + * GD_TRIANGLE - Triangle + * GD_WEIGHTED4 - 4 pixels weighted bilinear interpolation + * + * See also: + * <gdSetInterpolationMethod> + **/ +typedef enum { + GD_DEFAULT = 0, + GD_BELL, + GD_BESSEL, + GD_BILINEAR_FIXED, + GD_BICUBIC, + GD_BICUBIC_FIXED, + GD_BLACKMAN, + GD_BOX, + GD_BSPLINE, + GD_CATMULLROM, + GD_GAUSSIAN, + GD_GENERALIZED_CUBIC, + GD_HERMITE, + GD_HAMMING, + GD_HANNING, + GD_MITCHELL, + GD_NEAREST_NEIGHBOUR, + GD_POWER, + GD_QUADRATIC, + GD_SINC, + GD_TRIANGLE, + GD_WEIGHTED4, + GD_METHOD_COUNT = 21 +} gdInterpolationMethod; + +/* define struct with name and func ptr and add it to gdImageStruct gdInterpolationMethod interpolation; */ + +/* Interpolation function ptr */ +typedef double (* interpolation_method )(double); + + +/* + Group: Types + + typedef: gdImage + + typedef: gdImagePtr + + The data structure in which gd stores images. <gdImageCreate>, + <gdImageCreateTrueColor> and the various image file-loading functions + return a pointer to this type, and the other functions expect to + receive a pointer to this type as their first argument. + + *gdImagePtr* is a pointer to *gdImage*. + + (Previous versions of this library encouraged directly manipulating + the contents ofthe struct but we are attempting to move away from + this practice so the fields are no longer documented here. If you + need to poke at the internals of this struct, feel free to look at + *gd.h*.) +*/ +typedef struct gdImageStruct { + /* Palette-based image pixels */ + unsigned char **pixels; + int sx; + int sy; + /* These are valid in palette images only. See also + 'alpha', which appears later in the structure to + preserve binary backwards compatibility */ + int colorsTotal; + int red[gdMaxColors]; + int green[gdMaxColors]; + int blue[gdMaxColors]; + int open[gdMaxColors]; + /* For backwards compatibility, this is set to the + first palette entry with 100% transparency, + and is also set and reset by the + gdImageColorTransparent function. Newer + applications can allocate palette entries + with any desired level of transparency; however, + bear in mind that many viewers, notably + many web browsers, fail to implement + full alpha channel for PNG and provide + support for full opacity or transparency only. */ + int transparent; + int *polyInts; + int polyAllocated; + struct gdImageStruct *brush; + struct gdImageStruct *tile; + int brushColorMap[gdMaxColors]; + int tileColorMap[gdMaxColors]; + int styleLength; + int stylePos; + int *style; + int interlace; + /* New in 2.0: thickness of line. Initialized to 1. */ + int thick; + /* New in 2.0: alpha channel for palettes. Note that only + Macintosh Internet Explorer and (possibly) Netscape 6 + really support multiple levels of transparency in + palettes, to my knowledge, as of 2/15/01. Most + common browsers will display 100% opaque and + 100% transparent correctly, and do something + unpredictable and/or undesirable for levels + in between. TBB */ + int alpha[gdMaxColors]; + /* Truecolor flag and pixels. New 2.0 fields appear here at the + end to minimize breakage of existing object code. */ + int trueColor; + int **tpixels; + /* Should alpha channel be copied, or applied, each time a + pixel is drawn? This applies to truecolor images only. + No attempt is made to alpha-blend in palette images, + even if semitransparent palette entries exist. + To do that, build your image as a truecolor image, + then quantize down to 8 bits. */ + int alphaBlendingFlag; + /* Should the alpha channel of the image be saved? This affects + PNG at the moment; other future formats may also + have that capability. JPEG doesn't. */ + int saveAlphaFlag; + + /* There should NEVER BE ACCESSOR MACROS FOR ITEMS BELOW HERE, so this + part of the structure can be safely changed in new releases. */ + + /* 2.0.12: anti-aliased globals. 2.0.26: just a few vestiges after + switching to the fast, memory-cheap implementation from PHP-gd. */ + int AA; + int AA_color; + int AA_dont_blend; + + /* 2.0.12: simple clipping rectangle. These values + must be checked for safety when set; please use + gdImageSetClip */ + int cx1; + int cy1; + int cx2; + int cy2; + + /* 2.1.0: allows to specify resolution in dpi */ + unsigned int res_x; + unsigned int res_y; + + /* Selects quantization method, see gdImageTrueColorToPaletteSetMethod() and gdPaletteQuantizationMethod enum. */ + int paletteQuantizationMethod; + /* speed/quality trade-off. 1 = best quality, 10 = best speed. 0 = method-specific default. + Applicable to GD_QUANT_LIQ and GD_QUANT_NEUQUANT. */ + int paletteQuantizationSpeed; + /* Image will remain true-color if conversion to palette cannot achieve given quality. + Value from 1 to 100, 1 = ugly, 100 = perfect. Applicable to GD_QUANT_LIQ.*/ + int paletteQuantizationMinQuality; + /* Image will use minimum number of palette colors needed to achieve given quality. Must be higher than paletteQuantizationMinQuality + Value from 1 to 100, 1 = ugly, 100 = perfect. Applicable to GD_QUANT_LIQ.*/ + int paletteQuantizationMaxQuality; + gdInterpolationMethod interpolation_id; + interpolation_method interpolation; +} +gdImage; + +typedef gdImage *gdImagePtr; + + +/* Point type for use in polygon drawing. */ + +/** + * Group: Types + * + * typedef: gdPointF + * Defines a point in a 2D coordinate system using floating point + * values. + * x - Floating point position (increase from left to right) + * y - Floating point Row position (increase from top to bottom) + * + * typedef: gdPointFPtr + * Pointer to a <gdPointF> + * + * See also: + * <gdImageCreate>, <gdImageCreateTrueColor>, + **/ +typedef struct +{ + double x, y; +} +gdPointF, *gdPointFPtr; + + +/* + Group: Types + + typedef: gdFont + + typedef: gdFontPtr + + A font structure, containing the bitmaps of all characters in a + font. Used to declare the characteristics of a font. Text-output + functions expect these as their second argument, following the + <gdImagePtr> argument. <gdFontSmall> and <gdFontGetLarge> both + return one. + + You can provide your own font data by providing such a structure and + the associated pixel array. You can determine the width and height + of a single character in a font by examining the w and h members of + the structure. If you will not be creating your own fonts, you will + not need to concern yourself with the rest of the components of this + structure. + + Please see the files gdfontl.c and gdfontl.h for an example of + the proper declaration of this structure. + + > typedef struct { + > // # of characters in font + > int nchars; + > // First character is numbered... (usually 32 = space) + > int offset; + > // Character width and height + > int w; + > int h; + > // Font data; array of characters, one row after another. + > // Easily included in code, also easily loaded from + > // data files. + > char *data; + > } gdFont; + + gdFontPtr is a pointer to gdFont. + +*/ +typedef struct { + /* # of characters in font */ + int nchars; + /* First character is numbered... (usually 32 = space) */ + int offset; + /* Character width and height */ + int w; + int h; + /* Font data; array of characters, one row after another. + Easily included in code, also easily loaded from + data files. */ + char *data; +} +gdFont; + +/* Text functions take these. */ +typedef gdFont *gdFontPtr; + +typedef void(*gdErrorMethod)(int, const char *, va_list); + +BGD_DECLARE(void) gdSetErrorMethod(gdErrorMethod); +BGD_DECLARE(void) gdClearErrorMethod(void); + +/* For backwards compatibility only. Use gdImageSetStyle() + for MUCH more flexible line drawing. Also see + gdImageSetBrush(). */ +#define gdDashSize 4 + +/* Special colors. */ + +#define gdStyled (-2) +#define gdBrushed (-3) +#define gdStyledBrushed (-4) +#define gdTiled (-5) + +/* NOT the same as the transparent color index. + This is used in line styles only. */ +#define gdTransparent (-6) + +#define gdAntiAliased (-7) + +/* Functions to manipulate images. */ + +/* Creates a palette-based image (up to 256 colors). */ +BGD_DECLARE(gdImagePtr) gdImageCreate (int sx, int sy); + +/* An alternate name for the above (2.0). */ +#define gdImageCreatePalette gdImageCreate + +/* Creates a truecolor image (millions of colors). */ +BGD_DECLARE(gdImagePtr) gdImageCreateTrueColor (int sx, int sy); + +/* Creates an image from various file types. These functions + return a palette or truecolor image based on the + nature of the file being loaded. Truecolor PNG + stays truecolor; palette PNG stays palette-based; + JPEG is always truecolor. */ +BGD_DECLARE(gdImagePtr) gdImageCreateFromPng (FILE * fd); +BGD_DECLARE(gdImagePtr) gdImageCreateFromPngCtx (gdIOCtxPtr in); +BGD_DECLARE(gdImagePtr) gdImageCreateFromPngPtr (int size, void *data); + +/* These read the first frame only */ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGif (FILE * fd); +BGD_DECLARE(gdImagePtr) gdImageCreateFromGifCtx (gdIOCtxPtr in); +BGD_DECLARE(gdImagePtr) gdImageCreateFromGifPtr (int size, void *data); +BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMP (FILE * inFile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMPCtx (gdIOCtx * infile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMPPtr (int size, void *data); +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpeg (FILE * infile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegEx (FILE * infile, int ignore_warning); +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegCtx (gdIOCtx * infile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegCtxEx (gdIOCtx * infile, int ignore_warning); +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegPtr (int size, void *data); +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegPtrEx (int size, void *data, int ignore_warning); +BGD_DECLARE(gdImagePtr) gdImageCreateFromWebp (FILE * inFile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromWebpPtr (int size, void *data); +BGD_DECLARE(gdImagePtr) gdImageCreateFromWebpCtx (gdIOCtx * infile); + +BGD_DECLARE(gdImagePtr) gdImageCreateFromTiff(FILE *inFile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffCtx(gdIOCtx *infile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffPtr(int size, void *data); + +BGD_DECLARE(gdImagePtr) gdImageCreateFromTga( FILE * fp ); +BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaCtx(gdIOCtx* ctx); +BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaPtr(int size, void *data); + +BGD_DECLARE(gdImagePtr) gdImageCreateFromBmp (FILE * inFile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromBmpPtr (int size, void *data); +BGD_DECLARE(gdImagePtr) gdImageCreateFromBmpCtx (gdIOCtxPtr infile); +BGD_DECLARE(gdImagePtr) gdImageCreateFromFile(const char *filename); + + +/* + Group: Types + + typedef: gdSource + + typedef: gdSourcePtr + + *Note:* This interface is *obsolete* and kept only for + *compatibility. Use <gdIOCtx> instead. + + Represents a source from which a PNG can be read. Programmers who + do not wish to read PNGs from a file can provide their own + alternate input mechanism, using the <gdImageCreateFromPngSource> + function. See the documentation of that function for an example of + the proper use of this type. + + > typedef struct { + > int (*source) (void *context, char *buffer, int len); + > void *context; + > } gdSource, *gdSourcePtr; + + The source function must return -1 on error, otherwise the number + of bytes fetched. 0 is EOF, not an error! + + 'context' will be passed to your source function. + +*/ +typedef struct { + int (*source) (void *context, char *buffer, int len); + void *context; +} +gdSource, *gdSourcePtr; + +/* Deprecated in favor of gdImageCreateFromPngCtx */ +BGD_DECLARE(gdImagePtr) gdImageCreateFromPngSource (gdSourcePtr in); + +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd (FILE * in); +BGD_DECLARE(gdImagePtr) gdImageCreateFromGdCtx (gdIOCtxPtr in); +BGD_DECLARE(gdImagePtr) gdImageCreateFromGdPtr (int size, void *data); + +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2 (FILE * in); +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Ctx (gdIOCtxPtr in); +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Ptr (int size, void *data); + +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Part (FILE * in, int srcx, int srcy, int w, + int h); +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2PartCtx (gdIOCtxPtr in, int srcx, int srcy, + int w, int h); +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2PartPtr (int size, void *data, int srcx, int srcy, + int w, int h); +/* 2.0.10: prototype was missing */ +BGD_DECLARE(gdImagePtr) gdImageCreateFromXbm (FILE * in); +BGD_DECLARE(void) gdImageXbmCtx(gdImagePtr image, char* file_name, int fg, gdIOCtx * out); + +/* NOTE: filename, not FILE */ +BGD_DECLARE(gdImagePtr) gdImageCreateFromXpm (char *filename); + +BGD_DECLARE(void) gdImageDestroy (gdImagePtr im); + +/* Replaces or blends with the background depending on the + most recent call to gdImageAlphaBlending and the + alpha channel value of 'color'; default is to overwrite. + Tiling and line styling are also implemented + here. All other gd drawing functions pass through this call, + allowing for many useful effects. + Overlay and multiply effects are used when gdImageAlphaBlending + is passed gdEffectOverlay and gdEffectMultiply */ + +BGD_DECLARE(void) gdImageSetPixel (gdImagePtr im, int x, int y, int color); +/* FreeType 2 text output with hook to extra flags */ + +BGD_DECLARE(int) gdImageGetPixel (gdImagePtr im, int x, int y); +BGD_DECLARE(int) gdImageGetTrueColorPixel (gdImagePtr im, int x, int y); + +BGD_DECLARE(void) gdImageAABlend (gdImagePtr im); + +BGD_DECLARE(void) gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color); + +/* For backwards compatibility only. Use gdImageSetStyle() + for much more flexible line drawing. */ +BGD_DECLARE(void) gdImageDashedLine (gdImagePtr im, int x1, int y1, int x2, int y2, + int color); +/* Corners specified (not width and height). Upper left first, lower right + second. */ +BGD_DECLARE(void) gdImageRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, + int color); +/* Solid bar. Upper left corner first, lower right corner second. */ +BGD_DECLARE(void) gdImageFilledRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, + int color); +BGD_DECLARE(void) gdImageSetClip(gdImagePtr im, int x1, int y1, int x2, int y2); +BGD_DECLARE(void) gdImageGetClip(gdImagePtr im, int *x1P, int *y1P, int *x2P, int *y2P); +BGD_DECLARE(void) gdImageSetResolution(gdImagePtr im, const unsigned int res_x, const unsigned int res_y); +BGD_DECLARE(int) gdImageBoundsSafe (gdImagePtr im, int x, int y); +BGD_DECLARE(void) gdImageChar (gdImagePtr im, gdFontPtr f, int x, int y, int c, + int color); +BGD_DECLARE(void) gdImageCharUp (gdImagePtr im, gdFontPtr f, int x, int y, int c, + int color); +BGD_DECLARE(void) gdImageString (gdImagePtr im, gdFontPtr f, int x, int y, + unsigned char *s, int color); +BGD_DECLARE(void) gdImageStringUp (gdImagePtr im, gdFontPtr f, int x, int y, + unsigned char *s, int color); +BGD_DECLARE(void) gdImageString16 (gdImagePtr im, gdFontPtr f, int x, int y, + unsigned short *s, int color); +BGD_DECLARE(void) gdImageStringUp16 (gdImagePtr im, gdFontPtr f, int x, int y, + unsigned short *s, int color); + +/* 2.0.16: for thread-safe use of gdImageStringFT and friends, + call this before allowing any thread to call gdImageStringFT. + Otherwise it is invoked by the first thread to invoke + gdImageStringFT, with a very small but real risk of a race condition. + Return 0 on success, nonzero on failure to initialize freetype. */ +BGD_DECLARE(int) gdFontCacheSetup (void); + +/* Optional: clean up after application is done using fonts in + gdImageStringFT(). */ +BGD_DECLARE(void) gdFontCacheShutdown (void); +/* 2.0.20: for backwards compatibility. A few applications did start calling + this function when it first appeared although it was never documented. + Simply invokes gdFontCacheShutdown. */ +BGD_DECLARE(void) gdFreeFontCache (void); + +/* Calls gdImageStringFT. Provided for backwards compatibility only. */ +BGD_DECLARE(char *) gdImageStringTTF (gdImage * im, int *brect, int fg, char *fontlist, + double ptsize, double angle, int x, int y, + char *string); + +/* FreeType 2 text output */ +BGD_DECLARE(char *) gdImageStringFT (gdImage * im, int *brect, int fg, char *fontlist, + double ptsize, double angle, int x, int y, + char *string); + + +/* + Group: Types + + typedef: gdFTStringExtra + + typedef: gdFTStringExtraPtr + + A structure and associated pointer type used to pass additional + parameters to the <gdImageStringFTEx> function. See + <gdImageStringFTEx> for the structure definition. + + Thanks to Wez Furlong. +*/ + +/* 2.0.5: provides an extensible way to pass additional parameters. + Thanks to Wez Furlong, sorry for the delay. */ +typedef struct { + int flags; /* Logical OR of gdFTEX_ values */ + double linespacing; /* fine tune line spacing for '\n' */ + int charmap; /* TBB: 2.0.12: may be gdFTEX_Unicode, + gdFTEX_Shift_JIS, gdFTEX_Big5, + or gdFTEX_Adobe_Custom; + when not specified, maps are searched + for in the above order. */ + int hdpi; /* if (flags & gdFTEX_RESOLUTION) */ + int vdpi; /* if (flags & gdFTEX_RESOLUTION) */ + char *xshow; /* if (flags & gdFTEX_XSHOW) + then, on return, xshow is a malloc'ed + string containing xshow position data for + the last string. + + NB. The caller is responsible for gdFree'ing + the xshow string. + */ + char *fontpath; /* if (flags & gdFTEX_RETURNFONTPATHNAME) + then, on return, fontpath is a malloc'ed + string containing the actual font file path name + used, which can be interesting when fontconfig + is in use. + + The caller is responsible for gdFree'ing the + fontpath string. + */ + +} +gdFTStringExtra, *gdFTStringExtraPtr; + +#define gdFTEX_LINESPACE 1 +#define gdFTEX_CHARMAP 2 +#define gdFTEX_RESOLUTION 4 +#define gdFTEX_DISABLE_KERNING 8 +#define gdFTEX_XSHOW 16 +/* The default unless gdFTUseFontConfig(1); has been called: + fontlist is a full or partial font file pathname or list thereof + (i.e. just like before 2.0.29) */ +#define gdFTEX_FONTPATHNAME 32 +/* Necessary to use fontconfig patterns instead of font pathnames + as the fontlist argument, unless gdFTUseFontConfig(1); has + been called. New in 2.0.29 */ +#define gdFTEX_FONTCONFIG 64 +/* Sometimes interesting when fontconfig is used: the fontpath + element of the structure above will contain a gdMalloc'd string + copy of the actual font file pathname used, if this flag is set + when the call is made */ +#define gdFTEX_RETURNFONTPATHNAME 128 + +/* If flag is nonzero, the fontlist parameter to gdImageStringFT + and gdImageStringFTEx shall be assumed to be a fontconfig font pattern + if fontconfig was compiled into gd. This function returns zero + if fontconfig is not available, nonzero otherwise. */ +BGD_DECLARE(int) gdFTUseFontConfig(int flag); + +/* These are NOT flags; set one in 'charmap' if you set the + gdFTEX_CHARMAP bit in 'flags'. */ +#define gdFTEX_Unicode 0 +#define gdFTEX_Shift_JIS 1 +#define gdFTEX_Big5 2 +#define gdFTEX_Adobe_Custom 3 + +BGD_DECLARE(char *) gdImageStringFTEx (gdImage * im, int *brect, int fg, char *fontlist, + double ptsize, double angle, int x, int y, + char *string, gdFTStringExtraPtr strex); + + +/* + Group: Types + + typedef: gdPoint + + typedef: gdPointPtr + + Represents a point in the coordinate space of the image; used by + <gdImagePolygon>, <gdImageOpenPolygon> and <gdImageFilledPolygon> + for polygon drawing. + + > typedef struct { + > int x, y; + > } gdPoint, *gdPointPtr; + +*/ +typedef struct { + int x, y; +} +gdPoint, *gdPointPtr; + +typedef struct { + int x, y; + int width, height; +} +gdRect, *gdRectPtr; + + +BGD_DECLARE(void) gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c); +BGD_DECLARE(void) gdImageOpenPolygon (gdImagePtr im, gdPointPtr p, int n, int c); +BGD_DECLARE(void) gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c); + +/* These functions still work with truecolor images, + for which they never return error. */ +BGD_DECLARE(int) gdImageColorAllocate (gdImagePtr im, int r, int g, int b); +/* gd 2.0: palette entries with non-opaque transparency are permitted. */ +BGD_DECLARE(int) gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a); +/* Assumes opaque is the preferred alpha channel value */ +BGD_DECLARE(int) gdImageColorClosest (gdImagePtr im, int r, int g, int b); +/* Closest match taking all four parameters into account. + A slightly different color with the same transparency + beats the exact same color with radically different + transparency */ +BGD_DECLARE(int) gdImageColorClosestAlpha (gdImagePtr im, int r, int g, int b, int a); +/* An alternate method */ +BGD_DECLARE(int) gdImageColorClosestHWB (gdImagePtr im, int r, int g, int b); +/* Returns exact, 100% opaque matches only */ +BGD_DECLARE(int) gdImageColorExact (gdImagePtr im, int r, int g, int b); +/* Returns an exact match only, including alpha */ +BGD_DECLARE(int) gdImageColorExactAlpha (gdImagePtr im, int r, int g, int b, int a); +/* Opaque only */ +BGD_DECLARE(int) gdImageColorResolve (gdImagePtr im, int r, int g, int b); +/* Based on gdImageColorExactAlpha and gdImageColorClosestAlpha */ +BGD_DECLARE(int) gdImageColorResolveAlpha (gdImagePtr im, int r, int g, int b, int a); + +/* A simpler way to obtain an opaque truecolor value for drawing on a + truecolor image. Not for use with palette images! */ + +#define gdTrueColor(r, g, b) (((r) << 16) + \ + ((g) << 8) + \ + (b)) + +/* Returns a truecolor value with an alpha channel component. + gdAlphaMax (127, **NOT 255**) is transparent, 0 is completely + opaque. */ + +#define gdTrueColorAlpha(r, g, b, a) (((a) << 24) + \ + ((r) << 16) + \ + ((g) << 8) + \ + (b)) + +BGD_DECLARE(void) gdImageColorDeallocate (gdImagePtr im, int color); + +/* Converts a truecolor image to a palette-based image, + using a high-quality two-pass quantization routine + which attempts to preserve alpha channel information + as well as R/G/B color information when creating + a palette. If ditherFlag is set, the image will be + dithered to approximate colors better, at the expense + of some obvious "speckling." colorsWanted can be + anything up to 256. If the original source image + includes photographic information or anything that + came out of a JPEG, 256 is strongly recommended. + + Better yet, don't use these function -- write real + truecolor PNGs and JPEGs. The disk space gain of + conversion to palette is not great (for small images + it can be negative) and the quality loss is ugly. + + DIFFERENCES: gdImageCreatePaletteFromTrueColor creates and + returns a new image. gdImageTrueColorToPalette modifies + an existing image, and the truecolor pixels are discarded. + + gdImageTrueColorToPalette() returns TRUE on success, FALSE on failure. +*/ + +BGD_DECLARE(gdImagePtr) gdImageCreatePaletteFromTrueColor (gdImagePtr im, int ditherFlag, + int colorsWanted); + +BGD_DECLARE(int) gdImageTrueColorToPalette (gdImagePtr im, int ditherFlag, + int colorsWanted); + +BGD_DECLARE(int) gdImagePaletteToTrueColor(gdImagePtr src); + +/* An attempt at getting the results of gdImageTrueColorToPalette to + * look a bit more like the original (im1 is the original and im2 is + * the palette version */ + +BGD_DECLARE(int) gdImageColorMatch(gdImagePtr im1, gdImagePtr im2); + +/* Selects quantization method used for subsequent gdImageTrueColorToPalette calls. + See gdPaletteQuantizationMethod enum (e.g. GD_QUANT_NEUQUANT, GD_QUANT_LIQ). + Speed is from 1 (highest quality) to 10 (fastest). + Speed 0 selects method-specific default (recommended). + + Returns FALSE if the given method is invalid or not available. +*/ +BGD_DECLARE(int) gdImageTrueColorToPaletteSetMethod (gdImagePtr im, int method, int speed); + +/* + Chooses quality range that subsequent call to gdImageTrueColorToPalette will aim for. + Min and max quality is in range 1-100 (1 = ugly, 100 = perfect). Max must be higher than min. + If palette cannot represent image with at least min_quality, then image will remain true-color. + If palette can represent image with quality better than max_quality, then lower number of colors will be used. + This function has effect only when GD_QUANT_LIQ method has been selected and the source image is true-color. +*/ +BGD_DECLARE(void) gdImageTrueColorToPaletteSetQuality (gdImagePtr im, int min_quality, int max_quality); + +/* Specifies a color index (if a palette image) or an + RGB color (if a truecolor image) which should be + considered 100% transparent. FOR TRUECOLOR IMAGES, + THIS IS IGNORED IF AN ALPHA CHANNEL IS BEING + SAVED. Use gdImageSaveAlpha(im, 0); to + turn off the saving of a full alpha channel in + a truecolor image. Note that gdImageColorTransparent + is usually compatible with older browsers that + do not understand full alpha channels well. TBB */ +BGD_DECLARE(void) gdImageColorTransparent (gdImagePtr im, int color); + +BGD_DECLARE(void) gdImagePaletteCopy (gdImagePtr dst, gdImagePtr src); + +typedef int (*gdCallbackImageColor)(gdImagePtr im, int src); + +BGD_DECLARE(int) gdImageColorReplace(gdImagePtr im, int src, int dst); +BGD_DECLARE(int) gdImageColorReplaceThreshold(gdImagePtr im, int src, int dst, float threshold); +BGD_DECLARE(int) gdImageColorReplaceArray(gdImagePtr im, int len, int *src, int *dst); +BGD_DECLARE(int) gdImageColorReplaceCallback(gdImagePtr im, gdCallbackImageColor callback); + +BGD_DECLARE(void) gdImageGif (gdImagePtr im, FILE * out); +BGD_DECLARE(void) gdImagePng (gdImagePtr im, FILE * out); +BGD_DECLARE(void) gdImagePngCtx (gdImagePtr im, gdIOCtx * out); +BGD_DECLARE(void) gdImageGifCtx (gdImagePtr im, gdIOCtx * out); +BGD_DECLARE(void) gdImageTiff(gdImagePtr im, FILE *outFile); +BGD_DECLARE(void *) gdImageTiffPtr(gdImagePtr im, int *size); +BGD_DECLARE(void) gdImageTiffCtx(gdImagePtr image, gdIOCtx *out); + +BGD_DECLARE(void *) gdImageBmpPtr(gdImagePtr im, int *size, int compression); +BGD_DECLARE(void) gdImageBmp(gdImagePtr im, FILE *outFile, int compression); +BGD_DECLARE(void) gdImageBmpCtx(gdImagePtr im, gdIOCtxPtr out, int compression); + +/* 2.0.12: Compression level: 0-9 or -1, where 0 is NO COMPRESSION at all, + 1 is FASTEST but produces larger files, 9 provides the best + compression (smallest files) but takes a long time to compress, and + -1 selects the default compiled into the zlib library. */ +BGD_DECLARE(void) gdImagePngEx (gdImagePtr im, FILE * out, int level); +BGD_DECLARE(void) gdImagePngCtxEx (gdImagePtr im, gdIOCtx * out, int level); + +BGD_DECLARE(void) gdImageWBMP (gdImagePtr image, int fg, FILE * out); +BGD_DECLARE(void) gdImageWBMPCtx (gdImagePtr image, int fg, gdIOCtx * out); + +BGD_DECLARE(int) gdImageFile(gdImagePtr im, const char *filename); +BGD_DECLARE(int) gdSupportsFileType(const char *filename, int writing); + + +/* Guaranteed to correctly free memory returned by the gdImage*Ptr + functions */ +BGD_DECLARE(void) gdFree (void *m); + +/* Best to free this memory with gdFree(), not free() */ +BGD_DECLARE(void *) gdImageWBMPPtr (gdImagePtr im, int *size, int fg); + +/* 100 is highest quality (there is always a little loss with JPEG). + 0 is lowest. 10 is about the lowest useful setting. */ +BGD_DECLARE(void) gdImageJpeg (gdImagePtr im, FILE * out, int quality); +BGD_DECLARE(void) gdImageJpegCtx (gdImagePtr im, gdIOCtx * out, int quality); + +/* Best to free this memory with gdFree(), not free() */ +BGD_DECLARE(void *) gdImageJpegPtr (gdImagePtr im, int *size, int quality); + +BGD_DECLARE(void) gdImageWebpEx (gdImagePtr im, FILE * outFile, int quantization); +BGD_DECLARE(void) gdImageWebp (gdImagePtr im, FILE * outFile); +BGD_DECLARE(void *) gdImageWebpPtr (gdImagePtr im, int *size); +BGD_DECLARE(void *) gdImageWebpPtrEx (gdImagePtr im, int *size, int quantization); +BGD_DECLARE(void) gdImageWebpCtx (gdImagePtr im, gdIOCtx * outfile, int quantization); + + +/** + * Group: GifAnim + * + * Legal values for Disposal. gdDisposalNone is always used by + * the built-in optimizer if previm is passed. + * + * Constants: gdImageGifAnim + * + * gdDisposalUnknown - Not recommended + * gdDisposalNone - Preserve previous frame + * gdDisposalRestoreBackground - First allocated color of palette + * gdDisposalRestorePrevious - Restore to before start of frame + * + * See also: <gdImageGifAnimAdd> + */ +enum { + gdDisposalUnknown, + gdDisposalNone, + gdDisposalRestoreBackground, + gdDisposalRestorePrevious +}; + +BGD_DECLARE(void) gdImageGifAnimBegin(gdImagePtr im, FILE *outFile, int GlobalCM, int Loops); +BGD_DECLARE(void) gdImageGifAnimAdd(gdImagePtr im, FILE *outFile, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal, gdImagePtr previm); +BGD_DECLARE(void) gdImageGifAnimEnd(FILE *outFile); +BGD_DECLARE(void) gdImageGifAnimBeginCtx(gdImagePtr im, gdIOCtx *out, int GlobalCM, int Loops); +BGD_DECLARE(void) gdImageGifAnimAddCtx(gdImagePtr im, gdIOCtx *out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal, gdImagePtr previm); +BGD_DECLARE(void) gdImageGifAnimEndCtx(gdIOCtx *out); +BGD_DECLARE(void *) gdImageGifAnimBeginPtr(gdImagePtr im, int *size, int GlobalCM, int Loops); +BGD_DECLARE(void *) gdImageGifAnimAddPtr(gdImagePtr im, int *size, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal, gdImagePtr previm); +BGD_DECLARE(void *) gdImageGifAnimEndPtr(int *size); + + + +/* + Group: Types + + typedef: gdSink + + typedef: gdSinkPtr + + *Note:* This interface is *obsolete* and kept only for + *compatibility. Use <gdIOCtx> instead. + + Represents a "sink" (destination) to which a PNG can be + written. Programmers who do not wish to write PNGs to a file can + provide their own alternate output mechanism, using the + <gdImagePngToSink> function. See the documentation of that + function for an example of the proper use of this type. + + > typedef struct { + > int (*sink) (void *context, char *buffer, int len); + > void *context; + > } gdSink, *gdSinkPtr; + + The _sink_ function must return -1 on error, otherwise the number of + bytes written, which must be equal to len. + + _context_ will be passed to your sink function. + +*/ + +typedef struct { + int (*sink) (void *context, const char *buffer, int len); + void *context; +} +gdSink, *gdSinkPtr; + +BGD_DECLARE(void) gdImagePngToSink (gdImagePtr im, gdSinkPtr out); + +BGD_DECLARE(void) gdImageGd (gdImagePtr im, FILE * out); +BGD_DECLARE(void) gdImageGd2 (gdImagePtr im, FILE * out, int cs, int fmt); + +/* Best to free this memory with gdFree(), not free() */ +BGD_DECLARE(void *) gdImageGifPtr (gdImagePtr im, int *size); + +/* Best to free this memory with gdFree(), not free() */ +BGD_DECLARE(void *) gdImagePngPtr (gdImagePtr im, int *size); +BGD_DECLARE(void *) gdImagePngPtrEx (gdImagePtr im, int *size, int level); + +/* Best to free this memory with gdFree(), not free() */ +BGD_DECLARE(void *) gdImageGdPtr (gdImagePtr im, int *size); + +/* Best to free this memory with gdFree(), not free() */ +BGD_DECLARE(void *) gdImageGd2Ptr (gdImagePtr im, int cs, int fmt, int *size); + +/* Style is a bitwise OR ( | operator ) of these. + gdArc and gdChord are mutually exclusive; + gdChord just connects the starting and ending + angles with a straight line, while gdArc produces + a rounded edge. gdPie is a synonym for gdArc. + gdNoFill indicates that the arc or chord should be + outlined, not filled. gdEdged, used together with + gdNoFill, indicates that the beginning and ending + angles should be connected to the center; this is + a good way to outline (rather than fill) a + 'pie slice'. */ +#define gdArc 0 +#define gdPie gdArc +#define gdChord 1 +#define gdNoFill 2 +#define gdEdged 4 + +BGD_DECLARE(void) gdImageFilledArc (gdImagePtr im, int cx, int cy, int w, int h, int s, + int e, int color, int style); +BGD_DECLARE(void) gdImageArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, + int color); +BGD_DECLARE(void) gdImageEllipse(gdImagePtr im, int cx, int cy, int w, int h, int color); +BGD_DECLARE(void) gdImageFilledEllipse (gdImagePtr im, int cx, int cy, int w, int h, + int color); +BGD_DECLARE(void) gdImageFillToBorder (gdImagePtr im, int x, int y, int border, + int color); +BGD_DECLARE(void) gdImageFill (gdImagePtr im, int x, int y, int color); +BGD_DECLARE(void) gdImageCopy (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, + int srcX, int srcY, int w, int h); +BGD_DECLARE(void) gdImageCopyMerge (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, + int srcX, int srcY, int w, int h, int pct); +BGD_DECLARE(void) gdImageCopyMergeGray (gdImagePtr dst, gdImagePtr src, int dstX, + int dstY, int srcX, int srcY, int w, int h, + int pct); + +/* Stretches or shrinks to fit, as needed. Does NOT attempt + to average the entire set of source pixels that scale down onto the + destination pixel. */ +BGD_DECLARE(void) gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, + int srcX, int srcY, int dstW, int dstH, int srcW, + int srcH); + +/* gd 2.0: stretches or shrinks to fit, as needed. When called with a + truecolor destination image, this function averages the + entire set of source pixels that scale down onto the + destination pixel, taking into account what portion of the + destination pixel each source pixel represents. This is a + floating point operation, but this is not a performance issue + on modern hardware, except for some embedded devices. If the + destination is a palette image, gdImageCopyResized is + substituted automatically. */ +BGD_DECLARE(void) gdImageCopyResampled (gdImagePtr dst, gdImagePtr src, int dstX, + int dstY, int srcX, int srcY, int dstW, int dstH, + int srcW, int srcH); + +/* gd 2.0.8: gdImageCopyRotated is added. Source + is a rectangle, with its upper left corner at + srcX and srcY. Destination is the *center* of + the rotated copy. Angle is in degrees, same as + gdImageArc. Floating point destination center + coordinates allow accurate rotation of + objects of odd-numbered width or height. */ +BGD_DECLARE(void) gdImageCopyRotated (gdImagePtr dst, + gdImagePtr src, + double dstX, double dstY, + int srcX, int srcY, + int srcWidth, int srcHeight, int angle); + +BGD_DECLARE(gdImagePtr) gdImageClone (gdImagePtr src); + +BGD_DECLARE(void) gdImageSetBrush (gdImagePtr im, gdImagePtr brush); +BGD_DECLARE(void) gdImageSetTile (gdImagePtr im, gdImagePtr tile); +BGD_DECLARE(void) gdImageSetAntiAliased (gdImagePtr im, int c); +BGD_DECLARE(void) gdImageSetAntiAliasedDontBlend (gdImagePtr im, int c, int dont_blend); +BGD_DECLARE(void) gdImageSetStyle (gdImagePtr im, int *style, int noOfPixels); +/* Line thickness (defaults to 1). Affects lines, ellipses, + rectangles, polygons and so forth. */ +BGD_DECLARE(void) gdImageSetThickness (gdImagePtr im, int thickness); +/* On or off (1 or 0) for all three of these. */ +BGD_DECLARE(void) gdImageInterlace (gdImagePtr im, int interlaceArg); +BGD_DECLARE(void) gdImageAlphaBlending (gdImagePtr im, int alphaBlendingArg); +BGD_DECLARE(void) gdImageSaveAlpha (gdImagePtr im, int saveAlphaArg); + +BGD_DECLARE(gdImagePtr) gdImageNeuQuant(gdImagePtr im, const int max_color, int sample_factor); + +enum gdPixelateMode { + GD_PIXELATE_UPPERLEFT, + GD_PIXELATE_AVERAGE +}; + +BGD_DECLARE(int) gdImagePixelate(gdImagePtr im, int block_size, const unsigned int mode); + +typedef struct { + int sub; + int plus; + unsigned int num_colors; + int *colors; + unsigned int seed; +} gdScatter, *gdScatterPtr; + +BGD_DECLARE(int) gdImageScatter(gdImagePtr im, int sub, int plus); +BGD_DECLARE(int) gdImageScatterColor(gdImagePtr im, int sub, int plus, int colors[], unsigned int num_colors); +BGD_DECLARE(int) gdImageScatterEx(gdImagePtr im, gdScatterPtr s); +BGD_DECLARE(int) gdImageSmooth(gdImagePtr im, float weight); +BGD_DECLARE(int) gdImageMeanRemoval(gdImagePtr im); +BGD_DECLARE(int) gdImageEmboss(gdImagePtr im); +BGD_DECLARE(int) gdImageGaussianBlur(gdImagePtr im); +BGD_DECLARE(int) gdImageEdgeDetectQuick(gdImagePtr src); +BGD_DECLARE(int) gdImageSelectiveBlur( gdImagePtr src); +BGD_DECLARE(int) gdImageConvolution(gdImagePtr src, float filter[3][3], float filter_div, float offset); +BGD_DECLARE(int) gdImageColor(gdImagePtr src, const int red, const int green, const int blue, const int alpha); +BGD_DECLARE(int) gdImageContrast(gdImagePtr src, double contrast); +BGD_DECLARE(int) gdImageBrightness(gdImagePtr src, int brightness); +BGD_DECLARE(int) gdImageGrayScale(gdImagePtr src); +BGD_DECLARE(int) gdImageNegate(gdImagePtr src); + +BGD_DECLARE(gdImagePtr) gdImageCopyGaussianBlurred(gdImagePtr src, int radius, + double sigma); + + +/* Macros to access information about images. */ + +/* Returns nonzero if the image is a truecolor image, + zero for a palette image. */ +#define gdImageTrueColor(im) ((im)->trueColor) + +#define gdImageSX(im) ((im)->sx) +#define gdImageSY(im) ((im)->sy) +#define gdImageColorsTotal(im) ((im)->colorsTotal) +#define gdImageRed(im, c) ((im)->trueColor ? gdTrueColorGetRed(c) : \ + (im)->red[(c)]) +#define gdImageGreen(im, c) ((im)->trueColor ? gdTrueColorGetGreen(c) : \ + (im)->green[(c)]) +#define gdImageBlue(im, c) ((im)->trueColor ? gdTrueColorGetBlue(c) : \ + (im)->blue[(c)]) +#define gdImageAlpha(im, c) ((im)->trueColor ? gdTrueColorGetAlpha(c) : \ + (im)->alpha[(c)]) +#define gdImageGetTransparent(im) ((im)->transparent) +#define gdImageGetInterlaced(im) ((im)->interlace) + +/* These macros provide direct access to pixels in + palette-based and truecolor images, respectively. + If you use these macros, you must perform your own + bounds checking. Use of the macro for the correct type + of image is also your responsibility. */ +#define gdImagePalettePixel(im, x, y) (im)->pixels[(y)][(x)] +#define gdImageTrueColorPixel(im, x, y) (im)->tpixels[(y)][(x)] + +#define gdImageResolutionX(im) (im)->res_x +#define gdImageResolutionY(im) (im)->res_y + +/* I/O Support routines. */ + +BGD_DECLARE(gdIOCtx *) gdNewFileCtx (FILE *); +/* If data is null, size is ignored and an initial data buffer is + allocated automatically. NOTE: this function assumes gd has the right + to free or reallocate "data" at will! Also note that gd will free + "data" when the IO context is freed. If data is not null, it must point + to memory allocated with gdMalloc, or by a call to gdImage[something]Ptr. + If not, see gdNewDynamicCtxEx for an alternative. */ +BGD_DECLARE(gdIOCtx *) gdNewDynamicCtx (int size, void *data); +/* 2.0.21: if freeFlag is nonzero, gd will free and/or reallocate "data" as + needed as described above. If freeFlag is zero, gd will never free + or reallocate "data", which means that the context should only be used + for *reading* an image from a memory buffer, or writing an image to a + memory buffer which is already large enough. If the memory buffer is + not large enough and an image write is attempted, the write operation + will fail. Those wishing to write an image to a buffer in memory have + a much simpler alternative in the gdImage[something]Ptr functions. */ +BGD_DECLARE(gdIOCtx *) gdNewDynamicCtxEx (int size, void *data, int freeFlag); +BGD_DECLARE(gdIOCtx *) gdNewSSCtx (gdSourcePtr in, gdSinkPtr out); +BGD_DECLARE(void *) gdDPExtractData (struct gdIOCtx *ctx, int *size); + +#define GD2_CHUNKSIZE 128 +#define GD2_CHUNKSIZE_MIN 64 +#define GD2_CHUNKSIZE_MAX 4096 + +#define GD2_VERS 2 +#define GD2_ID "gd2" + +#define GD2_FMT_RAW 1 +#define GD2_FMT_COMPRESSED 2 + +/* Image comparison definitions */ +BGD_DECLARE(int) gdImageCompare (gdImagePtr im1, gdImagePtr im2); + +BGD_DECLARE(void) gdImageFlipHorizontal(gdImagePtr im); +BGD_DECLARE(void) gdImageFlipVertical(gdImagePtr im); +BGD_DECLARE(void) gdImageFlipBoth(gdImagePtr im); + +#define GD_FLIP_HORINZONTAL 1 +#define GD_FLIP_VERTICAL 2 +#define GD_FLIP_BOTH 3 + +/** + * Group: Crop + * + * Constants: gdCropMode + * GD_CROP_DEFAULT - Default crop mode (4 corners or background) + * GD_CROP_TRANSPARENT - Crop using the transparent color + * GD_CROP_BLACK - Crop black borders + * GD_CROP_WHITE - Crop white borders + * GD_CROP_SIDES - Crop using colors of the 4 corners + * + * See also: + * <gdImageAutoCrop> + **/ +enum gdCropMode { + GD_CROP_DEFAULT = 0, + GD_CROP_TRANSPARENT, + GD_CROP_BLACK, + GD_CROP_WHITE, + GD_CROP_SIDES, + GD_CROP_THRESHOLD +}; + +BGD_DECLARE(gdImagePtr) gdImageCrop(gdImagePtr src, const gdRect *crop); +BGD_DECLARE(gdImagePtr) gdImageCropAuto(gdImagePtr im, const unsigned int mode); +BGD_DECLARE(gdImagePtr) gdImageCropThreshold(gdImagePtr im, const unsigned int color, const float threshold); + +BGD_DECLARE(int) gdImageSetInterpolationMethod(gdImagePtr im, gdInterpolationMethod id); +BGD_DECLARE(gdInterpolationMethod) gdImageGetInterpolationMethod(gdImagePtr im); + +BGD_DECLARE(gdImagePtr) gdImageScale(const gdImagePtr src, const unsigned int new_width, const unsigned int new_height); + +BGD_DECLARE(gdImagePtr) gdImageRotateInterpolated(const gdImagePtr src, const float angle, int bgcolor); + +typedef enum { + GD_AFFINE_TRANSLATE = 0, + GD_AFFINE_SCALE, + GD_AFFINE_ROTATE, + GD_AFFINE_SHEAR_HORIZONTAL, + GD_AFFINE_SHEAR_VERTICAL +} gdAffineStandardMatrix; + +BGD_DECLARE(int) gdAffineApplyToPointF (gdPointFPtr dst, const gdPointFPtr src, const double affine[6]); +BGD_DECLARE(int) gdAffineInvert (double dst[6], const double src[6]); +BGD_DECLARE(int) gdAffineFlip (double dst_affine[6], const double src_affine[6], const int flip_h, const int flip_v); +BGD_DECLARE(int) gdAffineConcat (double dst[6], const double m1[6], const double m2[6]); + +BGD_DECLARE(int) gdAffineIdentity (double dst[6]); +BGD_DECLARE(int) gdAffineScale (double dst[6], const double scale_x, const double scale_y); +BGD_DECLARE(int) gdAffineRotate (double dst[6], const double angle); +BGD_DECLARE(int) gdAffineShearHorizontal (double dst[6], const double angle); +BGD_DECLARE(int) gdAffineShearVertical(double dst[6], const double angle); +BGD_DECLARE(int) gdAffineTranslate (double dst[6], const double offset_x, const double offset_y); +BGD_DECLARE(double) gdAffineExpansion (const double src[6]); +BGD_DECLARE(int) gdAffineRectilinear (const double src[6]); +BGD_DECLARE(int) gdAffineEqual (const double matrix1[6], const double matrix2[6]); +BGD_DECLARE(int) gdTransformAffineGetImage(gdImagePtr *dst, const gdImagePtr src, gdRectPtr src_area, const double affine[6]); +BGD_DECLARE(int) gdTransformAffineCopy(gdImagePtr dst, int dst_x, int dst_y, const gdImagePtr src, gdRectPtr src_region, const double affine[6]); +/* +gdTransformAffineCopy(gdImagePtr dst, int x0, int y0, int x1, int y1, + const gdImagePtr src, int src_width, int src_height, + const double affine[6]); +*/ +BGD_DECLARE(int) gdTransformAffineBoundingBox(gdRectPtr src, const double affine[6], gdRectPtr bbox); + +#define GD_CMP_IMAGE 1 /* Actual image IS different */ +#define GD_CMP_NUM_COLORS 2 /* Number of Colours in pallette differ */ +#define GD_CMP_COLOR 4 /* Image colours differ */ +#define GD_CMP_SIZE_X 8 /* Image width differs */ +#define GD_CMP_SIZE_Y 16 /* Image heights differ */ +#define GD_CMP_TRANSPARENT 32 /* Transparent colour */ +#define GD_CMP_BACKGROUND 64 /* Background colour */ +#define GD_CMP_INTERLACE 128 /* Interlaced setting */ +#define GD_CMP_TRUECOLOR 256 /* Truecolor vs palette differs */ + +/* resolution affects ttf font rendering, particularly hinting */ +#define GD_RESOLUTION 96 /* pixels per inch */ + + +/* Version information functions */ +BGD_DECLARE(int) gdMajorVersion(void); +BGD_DECLARE(int) gdMinorVersion(void); +BGD_DECLARE(int) gdReleaseVersion(void); +BGD_DECLARE(const char *) gdExtraVersion(void); +BGD_DECLARE(const char *) gdVersionString(void); + + +#ifdef __cplusplus +} +#endif + +/* newfangled special effects */ +#include "gdfx.h" + +#endif /* GD_H */ + +#ifdef __cplusplus +} +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd2copypal.c b/Build/source/libs/gd/libgd-2.1.1/src/gd2copypal.c new file mode 100644 index 00000000000..eaa67b55e6f --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd2copypal.c @@ -0,0 +1,63 @@ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include "gd.h" + +/* A short program which converts a .png file into a .gd file, for + your convenience in creating images on the fly from a + basis image that must be loaded quickly. The .gd format + is not intended to be a general-purpose format. */ + +int +main (int argc, char **argv) +{ + gdImagePtr im; + gdImagePtr pal; + FILE *in, *out; + if (argc != 3) { + fprintf(stderr, "Usage: gd2copypal palettefile.gd2 filename.gd2\n"); + exit (1); + } + in = fopen (argv[1], "rb"); + if (!in) { + fprintf(stderr, "Palette file does not exist!\n"); + exit (1); + } + pal = gdImageCreateFromGd2 (in); + fclose (in); + if (!pal) { + fprintf(stderr, "Palette is not in GD2 format!\n"); + exit (1); + } + + in = fopen (argv[2], "rb"); + if (!in) { + fprintf(stderr, "Input file does not exist!\n"); + exit (1); + } + im = gdImageCreateFromGd2 (in); + fclose (in); + if (!im) { + fprintf(stderr, "Input is not in GD2 format!\n"); + exit (1); + } + + gdImagePaletteCopy (im, pal); + + out = fopen (argv[2], "wb"); + if (!out) { + fprintf(stderr, "Output file cannot be written to!\n"); + gdImageDestroy (im); + exit (1); + } + gdImageGd2 (im, out, 128, 2); + fclose (out); + gdImageDestroy (pal); + gdImageDestroy (im); + + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd2time.c b/Build/source/libs/gd/libgd-2.1.1/src/gd2time.c new file mode 100644 index 00000000000..3c9e8af2c7b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd2time.c @@ -0,0 +1,60 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> /* for atoi */ +#include <time.h> /* For time */ +#include "gd.h" + +/* A short program which converts a .png file into a .gd file, for + your convenience in creating images on the fly from a + basis image that must be loaded quickly. The .gd format + is not intended to be a general-purpose format. */ + +int +main (int argc, char **argv) +{ + gdImagePtr im; + FILE *in; + int x, y, w, h; + int c; + int i; + int t0; + + if (argc != 7) { + fprintf(stderr, "Usage: gd2time filename.gd count x y w h\n"); + exit (1); + } + + c = atoi (argv[2]); + x = atoi (argv[3]); + y = atoi (argv[4]); + w = atoi (argv[5]); + h = atoi (argv[6]); + + printf ("Extracting %d times from (%d, %d), size is %dx%d\n", c, x, y, w, + h); + + t0 = time (0); + for (i = 0; i < c; i++) { + in = fopen (argv[1], "rb"); + if (!in) { + fprintf(stderr, "Input file does not exist!\n"); + exit (1); + } + + im = gdImageCreateFromGd2Part (in, x, y, w, h); + fclose (in); + + if (!im) { + fprintf(stderr, "Error reading source file!\n"); + exit (1); + } + gdImageDestroy (im); + }; + t0 = time (0) - t0; + printf ("%d seconds to extract (& destroy) %d times\n", t0, c); + + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd2togif.c b/Build/source/libs/gd/libgd-2.1.1/src/gd2togif.c new file mode 100644 index 00000000000..5a0be19b378 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd2togif.c @@ -0,0 +1,46 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> + +#include "gd.h" + +/* A short program which converts a .gif file into a .gd file, for + your convenience in creating images on the fly from a + basis image that must be loaded quickly. The .gd format + is not intended to be a general-purpose format. */ + +int main(int argc, char **argv) +{ + gdImagePtr im; + FILE *in, *out; + if (argc != 3) { + fprintf(stderr, "Usage: gd2togif filename.gd2 filename.gif\n"); + exit(1); + } + in = fopen(argv[1], "rb"); + if (!in) { + fprintf(stderr, "Input file does not exist!\n"); + exit(1); + } + im = gdImageCreateFromGd2(in); + fclose(in); + if (!im) { + fprintf(stderr, "Input is not in GD2 format!\n"); + exit(1); + } + out = fopen(argv[2], "wb"); + if (!out) { + fprintf(stderr, "Output file cannot be written to!\n"); + gdImageDestroy(im); + exit(1); + } + gdImageGif(im, out); + fclose(out); + gdImageDestroy(im); + + return 0; +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd2topng.c b/Build/source/libs/gd/libgd-2.1.1/src/gd2topng.c new file mode 100644 index 00000000000..6c0626f3b30 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd2topng.c @@ -0,0 +1,64 @@ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include "gd.h" + +/* A short program which converts a .png file into a .gd2 file, for + your convenience in creating images on the fly from a + basis image that must be loaded quickly. The .gd2 format + is not intended to be a general-purpose format. */ + +int +main (int argc, char **argv) +{ + gdImagePtr im; + FILE *in, *out; + int x=0, y=0, w=0, h=0; + if ((argc != 3) && (argc != 7)) { + fprintf (stderr, + "Usage: gd2topng filename.gd2 filename.png [srcx srcy width height]\n"); + fprintf (stderr, + "If the coordinates are absent,t he entire image is converted.\n"); + exit (1); + } + if (argc == 7) { + x = atoi (argv[3]); + y = atoi (argv[4]); + w = atoi (argv[5]); + h = atoi (argv[6]); + } + in = fopen (argv[1], "rb"); + if (!in) { + fprintf(stderr, "Input file does not exist!\n"); + exit (1); + } + if (argc == 7) { + im = gdImageCreateFromGd2Part (in, x, y, w, h); + } else { + im = gdImageCreateFromGd2 (in); + } + fclose (in); + if (!im) { + fprintf(stderr, "Input is not in GD2 format!\n"); + exit (1); + } + out = fopen (argv[2], "wb"); + if (!out) { + fprintf(stderr, "Output file cannot be written to!\n"); + gdImageDestroy (im); + exit (1); + } +#ifdef HAVE_LIBPNG + gdImagePng (im, out); +#else + fprintf(stderr, "No PNG library support available.\n"); +#endif + fclose (out); + gdImageDestroy (im); + + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_bmp.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_bmp.c new file mode 100644 index 00000000000..5f39b67c3e4 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_bmp.c @@ -0,0 +1,1066 @@ +/* + gd_bmp.c + + Bitmap format support for libgd + + * Written 2007, Scott MacVicar + --------------------------------------------------------------------------- + + Todo: + + Bitfield encoding + + ---------------------------------------------------------------------------- + */ +/* $Id$ */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" +#include "bmp.h" + +static int compress_row(unsigned char *uncompressed_row, int length); +static int build_rle_packet(unsigned char *row, int packet_type, int length, unsigned char *data); + +static int bmp_read_header(gdIOCtxPtr infile, bmp_hdr_t *hdr); +static int bmp_read_info(gdIOCtxPtr infile, bmp_info_t *info); +static int bmp_read_windows_v3_info(gdIOCtxPtr infile, bmp_info_t *info); +static int bmp_read_os2_v1_info(gdIOCtxPtr infile, bmp_info_t *info); +static int bmp_read_os2_v2_info(gdIOCtxPtr infile, bmp_info_t *info); + +static int bmp_read_direct(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header); +static int bmp_read_1bit(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header); +static int bmp_read_4bit(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header); +static int bmp_read_8bit(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header); +static int bmp_read_rle(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info); + +#define BMP_DEBUG(s) + +static int gdBMPPutWord(gdIOCtx *out, int w) +{ + /* Byte order is little-endian */ + gdPutC(w & 0xFF, out); + gdPutC((w >> 8) & 0xFF, out); + return 0; +} + +static int gdBMPPutInt(gdIOCtx *out, int w) +{ + /* Byte order is little-endian */ + gdPutC(w & 0xFF, out); + gdPutC((w >> 8) & 0xFF, out); + gdPutC((w >> 16) & 0xFF, out); + gdPutC((w >> 24) & 0xFF, out); + return 0; +} + +BGD_DECLARE(void *) gdImageBmpPtr(gdImagePtr im, int *size, int compression) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx(2048, NULL); + if (out == NULL) return NULL; + gdImageBmpCtx(im, out, compression); + rv = gdDPExtractData(out, size); + out->gd_free(out); + return rv; +} + +BGD_DECLARE(void) gdImageBmp(gdImagePtr im, FILE *outFile, int compression) +{ + gdIOCtx *out = gdNewFileCtx(outFile); + if (out == NULL) return; + gdImageBmpCtx(im, out, compression); + out->gd_free(out); +} + +BGD_DECLARE(void) gdImageBmpCtx(gdImagePtr im, gdIOCtxPtr out, int compression) +{ + int bitmap_size = 0, info_size, total_size, padding; + int i, row, xpos, pixel; + int error = 0; + unsigned char *uncompressed_row = NULL, *uncompressed_row_start = NULL; + FILE *tmpfile_for_compression = NULL; + gdIOCtxPtr out_original = NULL; + + /* No compression if its true colour or we don't support seek */ + if (im->trueColor) { + compression = 0; + } + + if (compression == 1 && !out->seek) { + /* Try to create a temp file where we can seek */ + if ((tmpfile_for_compression = tmpfile()) == NULL) { + compression = 0; + } else { + out_original = out; + if ((out = (gdIOCtxPtr)gdNewFileCtx(tmpfile_for_compression)) == NULL) { + out = out_original; + out_original = NULL; + compression = 0; + } + } + } + + bitmap_size = ((im->sx * (im->trueColor ? 24 : 8)) / 8) * im->sy; + + /* 40 byte Windows v3 header */ + info_size = BMP_WINDOWS_V3; + + /* data for the palette */ + if (!im->trueColor) { + info_size += im->colorsTotal * 4; + if (compression) { + bitmap_size = 0; + } + } + + /* bitmap header + info header + data */ + total_size = 14 + info_size + bitmap_size; + + /* write bmp header info */ + gdPutBuf("BM", 2, out); + gdBMPPutInt(out, total_size); + gdBMPPutWord(out, 0); + gdBMPPutWord(out, 0); + gdBMPPutInt(out, 14 + info_size); + + /* write Windows v3 headers */ + gdBMPPutInt(out, BMP_WINDOWS_V3); /* header size */ + gdBMPPutInt(out, im->sx); /* width */ + gdBMPPutInt(out, im->sy); /* height */ + gdBMPPutWord(out, 1); /* colour planes */ + gdBMPPutWord(out, (im->trueColor ? 24 : 8)); /* bit count */ + gdBMPPutInt(out, (compression ? BMP_BI_RLE8 : BMP_BI_RGB)); /* compression */ + gdBMPPutInt(out, bitmap_size); /* image size */ + gdBMPPutInt(out, 0); /* H resolution */ + gdBMPPutInt(out, 0); /* V ressolution */ + gdBMPPutInt(out, im->colorsTotal); /* colours used */ + gdBMPPutInt(out, 0); /* important colours */ + + /* The line must be divisible by 4, else its padded with NULLs */ + padding = ((int)(im->trueColor ? 3 : 1) * im->sx) % 4; + if (padding) { + padding = 4 - padding; + } + + /* 8-bit colours */ + if (!im->trueColor) { + for(i = 0; i< im->colorsTotal; ++i) { + Putchar(gdImageBlue(im, i), out); + Putchar(gdImageGreen(im, i), out); + Putchar(gdImageRed(im, i), out); + Putchar(0, out); + } + + if (compression) { + /* Can potentially change this to X + ((X / 128) * 3) */ + uncompressed_row = uncompressed_row_start = (unsigned char *) gdCalloc(gdImageSX(im) * 2, sizeof(char)); + if (!uncompressed_row) { + /* malloc failed */ + goto cleanup; + } + } + + for (row = (im->sy - 1); row >= 0; row--) { + if (compression) { + memset (uncompressed_row, 0, gdImageSX(im)); + } + + for (xpos = 0; xpos < im->sx; xpos++) { + if (compression) { + *uncompressed_row++ = (unsigned char)gdImageGetPixel(im, xpos, row); + } else { + Putchar(gdImageGetPixel(im, xpos, row), out); + } + } + + if (!compression) { + /* Add padding to make sure we have n mod 4 == 0 bytes per row */ + for (xpos = padding; xpos > 0; --xpos) { + Putchar('\0', out); + } + } else { + int compressed_size = 0; + uncompressed_row = uncompressed_row_start; + if ((compressed_size = compress_row(uncompressed_row, gdImageSX(im))) < 0) { + error = 1; + break; + } + bitmap_size += compressed_size; + + + gdPutBuf(uncompressed_row, compressed_size, out); + Putchar(BMP_RLE_COMMAND, out); + Putchar(BMP_RLE_ENDOFLINE, out); + bitmap_size += 2; + } + } + + if (compression && uncompressed_row) { + gdFree(uncompressed_row); + if (error != 0) { + goto cleanup; + } + /* Update filesize based on new values and set compression flag */ + Putchar(BMP_RLE_COMMAND, out); + Putchar(BMP_RLE_ENDOFBITMAP, out); + bitmap_size += 2; + + /* Write new total bitmap size */ + gdSeek(out, 2); + gdBMPPutInt(out, total_size + bitmap_size); + + /* Total length of image data */ + gdSeek(out, 34); + gdBMPPutInt(out, bitmap_size); + } + + } else { + for (row = (im->sy - 1); row >= 0; row--) { + for (xpos = 0; xpos < im->sx; xpos++) { + pixel = gdImageGetPixel(im, xpos, row); + + Putchar(gdTrueColorGetBlue(pixel), out); + Putchar(gdTrueColorGetGreen(pixel), out); + Putchar(gdTrueColorGetRed(pixel), out); + } + + /* Add padding to make sure we have n mod 4 == 0 bytes per row */ + for (xpos = padding; xpos > 0; --xpos) { + Putchar('\0', out); + } + } + } + + + /* If we needed a tmpfile for compression copy it over to out_original */ + if (tmpfile_for_compression) { + unsigned char* copy_buffer = NULL; + int buffer_size = 0; + + gdSeek(out, 0); + copy_buffer = (unsigned char *) gdMalloc(1024 * sizeof(unsigned char)); + if (copy_buffer == NULL) { + goto cleanup; + } + + while ((buffer_size = gdGetBuf(copy_buffer, 1024, out)) != EOF) { + if (buffer_size == 0) { + break; + } + gdPutBuf(copy_buffer , buffer_size, out_original); + } + gdFree(copy_buffer); + + /* Replace the temp with the original which now has data */ + out->gd_free(out); + out = out_original; + out_original = NULL; + } + +cleanup: + if (tmpfile_for_compression) { +#ifdef _WIN32 + _rmtmp(); +#else + fclose(tmpfile_for_compression); +#endif + tmpfile_for_compression = NULL; + } + + if (out_original) { + out_original->gd_free(out_original); + } + return; +} + +static int compress_row(unsigned char *row, int length) +{ + int rle_type = 0; + int compressed_length = 0; + int pixel = 0, compressed_run = 0, rle_compression = 0; + unsigned char *uncompressed_row = NULL, *uncompressed_rowp = NULL, *uncompressed_start = NULL; + + uncompressed_row = (unsigned char *) gdMalloc(length); + if (!uncompressed_row) { + return -1; + } + + memcpy(uncompressed_row, row, length); + uncompressed_start = uncompressed_rowp = uncompressed_row; + + for (pixel = 0; pixel < length; pixel++) { + if (compressed_run == 0) { + uncompressed_row = uncompressed_rowp; + compressed_run++; + uncompressed_rowp++; + rle_type = BMP_RLE_TYPE_RAW; + continue; + } + + if (compressed_run == 1) { + /* Compare next byte */ + if (memcmp(uncompressed_rowp, uncompressed_rowp - 1, 1) == 0) { + rle_type = BMP_RLE_TYPE_RLE; + } + } + + if (rle_type == BMP_RLE_TYPE_RLE) { + if (compressed_run >= 128 || memcmp(uncompressed_rowp, uncompressed_rowp - 1, 1) != 0) { + /* more than what we can store in a single run or run is over due to non match, force write */ + rle_compression = build_rle_packet(row, rle_type, compressed_run, uncompressed_row); + row += rle_compression; + compressed_length += rle_compression; + compressed_run = 0; + pixel--; + } else { + compressed_run++; + uncompressed_rowp++; + } + } else { + if (compressed_run >= 128 || memcmp(uncompressed_rowp, uncompressed_rowp - 1, 1) == 0) { + /* more than what we can store in a single run or run is over due to match, force write */ + rle_compression = build_rle_packet(row, rle_type, compressed_run, uncompressed_row); + row += rle_compression; + compressed_length += rle_compression; + compressed_run = 0; + pixel--; + } else { + /* add this pixel to the row */ + compressed_run++; + uncompressed_rowp++; + } + + } + } + + if (compressed_run) { + if (rle_type == BMP_RLE_TYPE_RLE) { + compressed_length += build_rle_packet(row, rle_type, compressed_run, uncompressed_row); + } else { + compressed_length += build_rle_packet(row, rle_type, compressed_run, uncompressed_row); + } + } + + gdFree(uncompressed_start); + + return compressed_length; +} + +static int build_rle_packet(unsigned char *row, int packet_type, int length, unsigned char *data) +{ + int compressed_size = 0; + if (length < 1 || length > 128) { + return 0; + } + + /* Bitmap specific cases is that we can't have uncompressed rows of length 1 or 2 */ + if (packet_type == BMP_RLE_TYPE_RAW && length < 3) { + int i = 0; + for (i = 0; i < length; i++) { + compressed_size += 2; + memset(row, 1, 1); + row++; + + memcpy(row, data++, 1); + row++; + } + } else if (packet_type == BMP_RLE_TYPE_RLE) { + compressed_size = 2; + memset(row, length, 1); + row++; + + memcpy(row, data, 1); + row++; + } else { + compressed_size = 2 + length; + memset(row, BMP_RLE_COMMAND, 1); + row++; + + memset(row, length, 1); + row++; + + memcpy(row, data, length); + row += length; + + /* Must be an even number for an uncompressed run */ + if (length % 2) { + memset(row, 0, 1); + row++; + compressed_size++; + } + } + return compressed_size; +} + +BGD_DECLARE(gdImagePtr) gdImageCreateFromBmp(FILE * inFile) +{ + gdImagePtr im = 0; + gdIOCtx *in = gdNewFileCtx(inFile); + if (in == NULL) return NULL; + im = gdImageCreateFromBmpCtx(in); + in->gd_free(in); + return im; +} + +BGD_DECLARE(gdImagePtr) gdImageCreateFromBmpPtr(int size, void *data) +{ + gdImagePtr im; + gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); + if (in == NULL) return NULL; + im = gdImageCreateFromBmpCtx(in); + in->gd_free(in); + return im; +} + +BGD_DECLARE(gdImagePtr) gdImageCreateFromBmpCtx(gdIOCtxPtr infile) +{ + bmp_hdr_t *hdr; + bmp_info_t *info; + gdImagePtr im = NULL; + int error = 0; + + if (!(hdr= (bmp_hdr_t *)gdCalloc(1, sizeof(bmp_hdr_t)))) { + return NULL; + } + + if (bmp_read_header(infile, hdr)) { + gdFree(hdr); + return NULL; + } + + if (hdr->magic != 0x4d42) { + gdFree(hdr); + return NULL; + } + + if (!(info = (bmp_info_t *)gdCalloc(1, sizeof(bmp_info_t)))) { + gdFree(hdr); + return NULL; + } + + if (bmp_read_info(infile, info)) { + gdFree(hdr); + gdFree(info); + return NULL; + } + + BMP_DEBUG(printf("Numcolours: %d\n", info->numcolors)); + BMP_DEBUG(printf("Width: %d\n", info->width)); + BMP_DEBUG(printf("Height: %d\n", info->height)); + BMP_DEBUG(printf("Planes: %d\n", info->numplanes)); + BMP_DEBUG(printf("Depth: %d\n", info->depth)); + BMP_DEBUG(printf("Offset: %d\n", hdr->off)); + + if (info->depth >= 16) { + im = gdImageCreateTrueColor(info->width, info->height); + } else { + im = gdImageCreate(info->width, info->height); + } + + if (!im) { + gdFree(hdr); + gdFree(info); + return NULL; + } + + switch (info->depth) { + case 1: + BMP_DEBUG(printf("1-bit image\n")); + error = bmp_read_1bit(im, infile, info, hdr); + break; + case 4: + BMP_DEBUG(printf("4-bit image\n")); + error = bmp_read_4bit(im, infile, info, hdr); + break; + case 8: + BMP_DEBUG(printf("8-bit image\n")); + error = bmp_read_8bit(im, infile, info, hdr); + break; + case 16: + case 24: + case 32: + BMP_DEBUG(printf("Direct BMP image\n")); + error = bmp_read_direct(im, infile, info, hdr); + break; + default: + BMP_DEBUG(printf("Unknown bit count\n")); + error = 1; + } + + gdFree(hdr); + gdFree(info); + + if (error) { + gdImageDestroy(im); + return NULL; + } + + return im; +} + +static int bmp_read_header(gdIOCtx *infile, bmp_hdr_t *hdr) +{ + if( + !gdGetWordLSB(&hdr->magic, infile) || + !gdGetIntLSB(&hdr->size, infile) || + !gdGetWordLSB(&hdr->reserved1, infile) || + !gdGetWordLSB(&hdr->reserved2 , infile) || + !gdGetIntLSB(&hdr->off , infile) + ) { + return 1; + } + return 0; +} + +static int bmp_read_info(gdIOCtx *infile, bmp_info_t *info) +{ + /* read BMP length so we can work out the version */ + if (!gdGetIntLSB(&info->len, infile)) { + return 1; + } + + switch (info->len) { + /* For now treat Windows v4 + v5 as v3 */ + case BMP_WINDOWS_V3: + case BMP_WINDOWS_V4: + case BMP_WINDOWS_V5: + BMP_DEBUG(printf("Reading Windows Header\n")); + if (bmp_read_windows_v3_info(infile, info)) { + return 1; + } + break; + case BMP_OS2_V1: + if (bmp_read_os2_v1_info(infile, info)) { + return 1; + } + break; + case BMP_OS2_V2: + if (bmp_read_os2_v2_info(infile, info)) { + return 1; + } + break; + default: + BMP_DEBUG(printf("Unhandled bitmap\n")); + return 1; + } + return 0; +} + +static int bmp_read_windows_v3_info(gdIOCtxPtr infile, bmp_info_t *info) +{ + if ( + !gdGetIntLSB(&info->width, infile) || + !gdGetIntLSB(&info->height, infile) || + !gdGetWordLSB(&info->numplanes, infile) || + !gdGetWordLSB(&info->depth, infile) || + !gdGetIntLSB(&info->enctype, infile) || + !gdGetIntLSB(&info->size, infile) || + !gdGetIntLSB(&info->hres, infile) || + !gdGetIntLSB(&info->vres, infile) || + !gdGetIntLSB(&info->numcolors, infile) || + !gdGetIntLSB(&info->mincolors, infile) + ) { + return 1; + } + + if (info->height < 0) { + info->topdown = 1; + info->height = -info->height; + } else { + info->topdown = 0; + } + + info->type = BMP_PALETTE_4; + + if (info->width <= 0 || info->height <= 0 || info->numplanes <= 0 || + info->depth <= 0 || info->numcolors < 0 || info->mincolors < 0) { + return 1; + } + + return 0; +} + +static int bmp_read_os2_v1_info(gdIOCtxPtr infile, bmp_info_t *info) +{ + if ( + !gdGetWordLSB((signed short int *)&info->width, infile) || + !gdGetWordLSB((signed short int *)&info->height, infile) || + !gdGetWordLSB(&info->numplanes, infile) || + !gdGetWordLSB(&info->depth, infile) + ) { + return 1; + } + + /* OS2 v1 doesn't support topdown */ + info->topdown = 0; + + info->numcolors = 1 << info->depth; + info->type = BMP_PALETTE_3; + + if (info->width <= 0 || info->height <= 0 || info->numplanes <= 0 || + info->depth <= 0 || info->numcolors < 0) { + return 1; + } + + return 0; +} + +static int bmp_read_os2_v2_info(gdIOCtxPtr infile, bmp_info_t *info) +{ + char useless_bytes[24]; + if ( + !gdGetIntLSB(&info->width, infile) || + !gdGetIntLSB(&info->height, infile) || + !gdGetWordLSB(&info->numplanes, infile) || + !gdGetWordLSB(&info->depth, infile) || + !gdGetIntLSB(&info->enctype, infile) || + !gdGetIntLSB(&info->size, infile) || + !gdGetIntLSB(&info->hres, infile) || + !gdGetIntLSB(&info->vres, infile) || + !gdGetIntLSB(&info->numcolors, infile) || + !gdGetIntLSB(&info->mincolors, infile) + ) { + return 1; + } + + /* Lets seek the next 24 pointless bytes, we don't care too much about it */ + if (!gdGetBuf(useless_bytes, 24, infile)) { + return 1; + } + + if (info->height < 0) { + info->topdown = 1; + info->height = -info->height; + } else { + info->topdown = 0; + } + + info->type = BMP_PALETTE_4; + + if (info->width <= 0 || info->height <= 0 || info->numplanes <= 0 || + info->depth <= 0 || info->numcolors < 0 || info->mincolors < 0) { + return 1; + } + + + return 0; +} + +static int bmp_read_direct(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header) +{ + int ypos = 0, xpos = 0, row = 0; + int padding = 0, alpha = 0, red = 0, green = 0, blue = 0; + signed short int data = 0; + + switch(info->enctype) { + case BMP_BI_RGB: + /* no-op */ + break; + + case BMP_BI_BITFIELDS: + if (info->depth == 24) { + BMP_DEBUG(printf("Bitfield compression isn't supported for 24-bit\n")); + return 1; + } + BMP_DEBUG(printf("Currently no bitfield support\n")); + return 1; + break; + + case BMP_BI_RLE8: + if (info->depth != 8) { + BMP_DEBUG(printf("RLE is only valid for 8-bit images\n")); + return 1; + } + case BMP_BI_RLE4: + if (info->depth != 4) { + BMP_DEBUG(printf("RLE is only valid for 4-bit images\n")); + return 1; + } + case BMP_BI_JPEG: + case BMP_BI_PNG: + default: + BMP_DEBUG(printf("Unsupported BMP compression format\n")); + return 1; + } + + /* There is a chance the data isn't until later, would be wierd but it is possible */ + if (gdTell(infile) != header->off) { + /* Should make sure we don't seek past the file size */ + gdSeek(infile, header->off); + } + + /* The line must be divisible by 4, else its padded with NULLs */ + padding = ((int)(info->depth / 8) * info->width) % 4; + if (padding) { + padding = 4 - padding; + } + + + for (ypos = 0; ypos < info->height; ++ypos) { + if (info->topdown) { + row = ypos; + } else { + row = info->height - ypos - 1; + } + + for (xpos = 0; xpos < info->width; xpos++) { + if (info->depth == 16) { + if (!gdGetWordLSB(&data, infile)) { + return 1; + } + BMP_DEBUG(printf("Data: %X\n", data)); + red = ((data & 0x7C00) >> 10) << 3; + green = ((data & 0x3E0) >> 5) << 3; + blue = (data & 0x1F) << 3; + BMP_DEBUG(printf("R: %d, G: %d, B: %d\n", red, green, blue)); + } else if (info->depth == 24) { + if (!gdGetByte(&blue, infile) || !gdGetByte(&green, infile) || !gdGetByte(&red, infile)) { + return 1; + } + } else { + if (!gdGetByte(&blue, infile) || !gdGetByte(&green, infile) || !gdGetByte(&red, infile) || !gdGetByte(&alpha, infile)) { + return 1; + } + } + /*alpha = gdAlphaMax - (alpha >> 1);*/ + gdImageSetPixel(im, xpos, row, gdTrueColor(red, green, blue)); + } + for (xpos = padding; xpos > 0; --xpos) { + if (!gdGetByte(&red, infile)) { + return 1; + } + } + } + + return 0; +} + +static int bmp_read_palette(gdImagePtr im, gdIOCtxPtr infile, int count, int read_four) +{ + int i; + int r, g, b, z; + + for (i = 0; i < count; i++) { + if ( + !gdGetByte(&b, infile) || + !gdGetByte(&g, infile) || + !gdGetByte(&r, infile) || + (read_four && !gdGetByte(&z, infile)) + ) { + return 1; + } + im->red[i] = r; + im->green[i] = g; + im->blue[i] = b; + im->open[i] = 1; + } + return 0; +} + +static int bmp_read_1bit(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header) +{ + int ypos = 0, xpos = 0, row = 0, index = 0; + int padding = 0, current_byte = 0, bit = 0; + + if (info->enctype != BMP_BI_RGB) { + return 1; + } + + if (!info->numcolors) { + info->numcolors = 2; + } else if (info->numcolors < 0 || info->numcolors > 2) { + return 1; + } + + if (bmp_read_palette(im, infile, info->numcolors, (info->type == BMP_PALETTE_4))) { + return 1; + } + + im->colorsTotal = info->numcolors; + + /* There is a chance the data isn't until later, would be wierd but it is possible */ + if (gdTell(infile) != header->off) { + /* Should make sure we don't seek past the file size */ + gdSeek(infile, header->off); + } + + /* The line must be divisible by 4, else its padded with NULLs */ + padding = ((int)ceil(0.1 * info->width)) % 4; + if (padding) { + padding = 4 - padding; + } + + for (ypos = 0; ypos < info->height; ++ypos) { + if (info->topdown) { + row = ypos; + } else { + row = info->height - ypos - 1; + } + + for (xpos = 0; xpos < info->width; xpos += 8) { + /* Bitmaps are always aligned in bytes so we'll never overflow */ + if (!gdGetByte(¤t_byte, infile)) { + return 1; + } + + for (bit = 0; bit < 8; bit++) { + index = ((current_byte & (0x80 >> bit)) != 0 ? 0x01 : 0x00); + if (im->open[index]) { + im->open[index] = 0; + } + gdImageSetPixel(im, xpos + bit, row, index); + /* No need to read anything extra */ + if ((xpos + bit) >= info->width) { + break; + } + } + } + + for (xpos = padding; xpos > 0; --xpos) { + if (!gdGetByte(&index, infile)) { + return 1; + } + } + } + return 0; +} + +static int bmp_read_4bit(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header) +{ + int ypos = 0, xpos = 0, row = 0, index = 0; + int padding = 0, current_byte = 0; + + if (info->enctype != BMP_BI_RGB && info->enctype != BMP_BI_RLE4) { + return 1; + } + + if (!info->numcolors) { + info->numcolors = 16; + } else if (info->numcolors < 0 || info->numcolors > 16) { + return 1; + } + + if (bmp_read_palette(im, infile, info->numcolors, (info->type == BMP_PALETTE_4))) { + return 1; + } + + im->colorsTotal = info->numcolors; + + /* There is a chance the data isn't until later, would be wierd but it is possible */ + if (gdTell(infile) != header->off) { + /* Should make sure we don't seek past the file size */ + gdSeek(infile, header->off); + } + + /* The line must be divisible by 4, else its padded with NULLs */ + padding = ((int)ceil(0.5 * info->width)) % 4; + if (padding) { + padding = 4 - padding; + } + + switch (info->enctype) { + case BMP_BI_RGB: + for (ypos = 0; ypos < info->height; ++ypos) { + if (info->topdown) { + row = ypos; + } else { + row = info->height - ypos - 1; + } + + for (xpos = 0; xpos < info->width; xpos += 2) { + if (!gdGetByte(¤t_byte, infile)) { + return 1; + } + + index = (current_byte >> 4) & 0x0f; + if (im->open[index]) { + im->open[index] = 0; + } + gdImageSetPixel(im, xpos, row, index); + + /* This condition may get called often, potential optimsations */ + if (xpos >= info->width) { + break; + } + + index = current_byte & 0x0f; + if (im->open[index]) { + im->open[index] = 0; + } + gdImageSetPixel(im, xpos + 1, row, index); + } + + for (xpos = padding; xpos > 0; --xpos) { + if (!gdGetByte(&index, infile)) { + return 1; + } + } + } + break; + + case BMP_BI_RLE4: + if (bmp_read_rle(im, infile, info)) { + return 1; + } + break; + + default: + return 1; + } + return 0; +} + +static int bmp_read_8bit(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header) +{ + int ypos = 0, xpos = 0, row = 0, index = 0; + int padding = 0; + + if (info->enctype != BMP_BI_RGB && info->enctype != BMP_BI_RLE8) { + return 1; + } + + if (!info->numcolors) { + info->numcolors = 256; + } else if (info->numcolors < 0 || info->numcolors > 256) { + return 1; + } + + if (bmp_read_palette(im, infile, info->numcolors, (info->type == BMP_PALETTE_4))) { + return 1; + } + + im->colorsTotal = info->numcolors; + + /* There is a chance the data isn't until later, would be wierd but it is possible */ + if (gdTell(infile) != header->off) { + /* Should make sure we don't seek past the file size */ + gdSeek(infile, header->off); + } + + /* The line must be divisible by 4, else its padded with NULLs */ + padding = (1 * info->width) % 4; + if (padding) { + padding = 4 - padding; + } + + switch (info->enctype) { + case BMP_BI_RGB: + for (ypos = 0; ypos < info->height; ++ypos) { + if (info->topdown) { + row = ypos; + } else { + row = info->height - ypos - 1; + } + + for (xpos = 0; xpos < info->width; ++xpos) { + if (!gdGetByte(&index, infile)) { + return 1; + } + + if (im->open[index]) { + im->open[index] = 0; + } + gdImageSetPixel(im, xpos, row, index); + } + /* Could create a new variable, but it isn't really worth it */ + for (xpos = padding; xpos > 0; --xpos) { + if (!gdGetByte(&index, infile)) { + return 1; + } + } + } + break; + + case BMP_BI_RLE8: + if (bmp_read_rle(im, infile, info)) { + return 1; + } + break; + + default: + return 1; + } + return 0; +} + +static int bmp_read_rle(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info) +{ + int ypos = 0, xpos = 0, row = 0, index = 0; + int rle_length = 0, rle_data = 0; + int padding = 0; + int i = 0, j = 0; + int pixels_per_byte = 8 / info->depth; + + for (ypos = 0; ypos < info->height && xpos <= info->width;) { + if (!gdGetByte(&rle_length, infile) || !gdGetByte(&rle_data, infile)) { + return 1; + } + row = info->height - ypos - 1; + + if (rle_length != BMP_RLE_COMMAND) { + if (im->open[rle_data]) { + im->open[rle_data] = 0; + } + + for (i = 0; (i < rle_length) && (xpos < info->width);) { + for (j = 1; (j <= pixels_per_byte) && (xpos < info->width) && (i < rle_length); j++, xpos++, i++) { + index = (rle_data & (((1 << info->depth) - 1) << (8 - (j * info->depth)))) >> (8 - (j * info->depth)); + if (im->open[index]) { + im->open[index] = 0; + } + gdImageSetPixel(im, xpos, row, index); + } + } + } else if (rle_length == BMP_RLE_COMMAND && rle_data > 2) { + /* Uncompressed RLE needs to be even */ + padding = 0; + for (i = 0; (i < rle_data) && (xpos < info->width); i += pixels_per_byte) { + int max_pixels = pixels_per_byte; + + if (!gdGetByte(&index, infile)) { + return 1; + } + padding++; + + if (rle_data - i < max_pixels) { + max_pixels = rle_data - i; + } + + for (j = 1; (j <= max_pixels) && (xpos < info->width); j++, xpos++) { + int temp = (index >> (8 - (j * info->depth))) & ((1 << info->depth) - 1); + if (im->open[temp]) { + im->open[temp] = 0; + } + gdImageSetPixel(im, xpos, row, temp); + } + } + + /* Make sure the bytes read are even */ + if (padding % 2 && !gdGetByte(&index, infile)) { + return 1; + } + } else if (rle_length == BMP_RLE_COMMAND && rle_data == BMP_RLE_ENDOFLINE) { + /* Next Line */ + xpos = 0; + ypos++; + } else if (rle_length == BMP_RLE_COMMAND && rle_data == BMP_RLE_DELTA) { + /* Delta Record, used for bmp files that contain other data*/ + if (!gdGetByte(&rle_length, infile) || !gdGetByte(&rle_data, infile)) { + return 1; + } + xpos += rle_length; + ypos += rle_data; + } else if (rle_length == BMP_RLE_COMMAND && rle_data == BMP_RLE_ENDOFBITMAP) { + /* End of bitmap */ + break; + } + } + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_color.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_color.c new file mode 100644 index 00000000000..6d8a8466b8a --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_color.c @@ -0,0 +1,30 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gd.h" +#include "gd_color.h" + +int gdColorMatch(gdImagePtr im, int col1, int col2, float threshold) +{ + const int dr = gdImageRed(im, col1) - gdImageRed(im, col2); + const int dg = gdImageGreen(im, col1) - gdImageGreen(im, col2); + const int db = gdImageBlue(im, col1) - gdImageBlue(im, col2); + const int da = gdImageAlpha(im, col1) - gdImageAlpha(im, col2); + const int dist = dr * dr + dg * dg + db * db + da * da; + + return (100.0 * dist / 195075) < threshold; +} + +/* + * To be implemented when we have more image formats. + * Buffer like gray8 gray16 or rgb8 will require some tweak + * and can be done in this function (called from the autocrop + * function. (Pierre) + */ +#if 0 +static int colors_equal (const int col1, const in col2) +{ + +} +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_color.h b/Build/source/libs/gd/libgd-2.1.1/src/gd_color.h new file mode 100644 index 00000000000..08b06cee09b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_color.h @@ -0,0 +1,14 @@ +#ifndef GD_COLOR_H +#define GD_COLOR_H 1 + +#ifdef __cplusplus +extern "C" { +#endif + + int gdColorMatch(gdImagePtr im, int col1, int col2, float threshold); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_color_map.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_color_map.c new file mode 100644 index 00000000000..ff48399a982 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_color_map.c @@ -0,0 +1,791 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <string.h> + +#include "gd.h" +#include "gd_color_map.h" + +static const gdColorMapEntry GD_COLOR_MAP_X11_ENTRIES[] = { + {"AliceBlue", 240, 248, 255}, + {"AntiqueWhite", 250, 235, 215}, + {"AntiqueWhite1", 255, 239, 219}, + {"AntiqueWhite2", 238, 223, 204}, + {"AntiqueWhite3", 205, 192, 176}, + {"AntiqueWhite4", 139, 131, 120}, + {"BlanchedAlmond", 255, 235, 205}, + {"BlueViolet", 138, 43, 226}, + {"CadetBlue", 95, 158, 160}, + {"CadetBlue1", 152, 245, 255}, + {"CadetBlue2", 142, 229, 238}, + {"CadetBlue3", 122, 197, 205}, + {"CadetBlue4", 83, 134, 139}, + {"CornflowerBlue", 100, 149, 237}, + {"DarkBlue", 0, 0, 139}, + {"DarkCyan", 0, 139, 139}, + {"DarkGoldenrod", 184, 134, 11}, + {"DarkGoldenrod1", 255, 185, 15}, + {"DarkGoldenrod2", 238, 173, 14}, + {"DarkGoldenrod3", 205, 149, 12}, + {"DarkGoldenrod4", 139, 101, 8}, + {"DarkGray", 169, 169, 169}, + {"DarkGreen", 0, 100, 0}, + {"DarkGrey", 169, 169, 169}, + {"DarkKhaki", 189, 183, 107}, + {"DarkMagenta", 139, 0, 139}, + {"DarkOliveGreen", 85, 107, 47}, + {"DarkOliveGreen1", 202, 255, 112}, + {"DarkOliveGreen2", 188, 238, 104}, + {"DarkOliveGreen3", 162, 205, 90}, + {"DarkOliveGreen4", 110, 139, 61}, + {"DarkOrange", 255, 140, 0}, + {"DarkOrange1", 255, 127, 0}, + {"DarkOrange2", 238, 118, 0}, + {"DarkOrange3", 205, 102, 0}, + {"DarkOrange4", 139, 69, 0}, + {"DarkOrchid", 153, 50, 204}, + {"DarkOrchid1", 191, 62, 255}, + {"DarkOrchid2", 178, 58, 238}, + {"DarkOrchid3", 154, 50, 205}, + {"DarkOrchid4", 104, 34, 139}, + {"DarkRed", 139, 0, 0}, + {"DarkSalmon", 233, 150, 122}, + {"DarkSeaGreen", 143, 188, 143}, + {"DarkSeaGreen1", 193, 255, 193}, + {"DarkSeaGreen2", 180, 238, 180}, + {"DarkSeaGreen3", 155, 205, 155}, + {"DarkSeaGreen4", 105, 139, 105}, + {"DarkSlateBlue", 72, 61, 139}, + {"DarkSlateGray", 47, 79, 79}, + {"DarkSlateGray1", 151, 255, 255}, + {"DarkSlateGray2", 141, 238, 238}, + {"DarkSlateGray3", 121, 205, 205}, + {"DarkSlateGray4", 82, 139, 139}, + {"DarkSlateGrey", 47, 79, 79}, + {"DarkTurquoise", 0, 206, 209}, + {"DarkViolet", 148, 0, 211}, + {"DeepPink", 255, 20, 147}, + {"DeepPink1", 255, 20, 147}, + {"DeepPink2", 238, 18, 137}, + {"DeepPink3", 205, 16, 118}, + {"DeepPink4", 139, 10, 80}, + {"DeepSkyBlue", 0, 191, 255}, + {"DeepSkyBlue1", 0, 191, 255}, + {"DeepSkyBlue2", 0, 178, 238}, + {"DeepSkyBlue3", 0, 154, 205}, + {"DeepSkyBlue4", 0, 104, 139}, + {"DimGray", 105, 105, 105}, + {"DimGrey", 105, 105, 105}, + {"DodgerBlue", 30, 144, 255}, + {"DodgerBlue1", 30, 144, 255}, + {"DodgerBlue2", 28, 134, 238}, + {"DodgerBlue3", 24, 116, 205}, + {"DodgerBlue4", 16, 78, 139}, + {"FloralWhite", 255, 250, 240}, + {"ForestGreen", 34, 139, 34}, + {"GhostWhite", 248, 248, 255}, + {"GreenYellow", 173, 255, 47}, + {"HotPink", 255, 105, 180}, + {"HotPink1", 255, 110, 180}, + {"HotPink2", 238, 106, 167}, + {"HotPink3", 205, 96, 144}, + {"HotPink4", 139, 58, 98}, + {"IndianRed", 205, 92, 92}, + {"IndianRed1", 255, 106, 106}, + {"IndianRed2", 238, 99, 99}, + {"IndianRed3", 205, 85, 85}, + {"IndianRed4", 139, 58, 58}, + {"LavenderBlush", 255, 240, 245}, + {"LavenderBlush1", 255, 240, 245}, + {"LavenderBlush2", 238, 224, 229}, + {"LavenderBlush3", 205, 193, 197}, + {"LavenderBlush4", 139, 131, 134}, + {"LawnGreen", 124, 252, 0}, + {"LemonChiffon", 255, 250, 205}, + {"LemonChiffon1", 255, 250, 205}, + {"LemonChiffon2", 238, 233, 191}, + {"LemonChiffon3", 205, 201, 165}, + {"LemonChiffon4", 139, 137, 112}, + {"LightBlue", 173, 216, 230}, + {"LightBlue1", 191, 239, 255}, + {"LightBlue2", 178, 223, 238}, + {"LightBlue3", 154, 192, 205}, + {"LightBlue4", 104, 131, 139}, + {"LightCoral", 240, 128, 128}, + {"LightCyan", 224, 255, 255}, + {"LightCyan1", 224, 255, 255}, + {"LightCyan2", 209, 238, 238}, + {"LightCyan3", 180, 205, 205}, + {"LightCyan4", 122, 139, 139}, + {"LightGoldenrod", 238, 221, 130}, + {"LightGoldenrod1", 255, 236, 139}, + {"LightGoldenrod2", 238, 220, 130}, + {"LightGoldenrod3", 205, 190, 112}, + {"LightGoldenrod4", 139, 129, 76}, + {"LightGoldenrodYellow", 250, 250, 210}, + {"LightGray", 211, 211, 211}, + {"LightGreen", 144, 238, 144}, + {"LightGrey", 211, 211, 211}, + {"LightPink", 255, 182, 193}, + {"LightPink1", 255, 174, 185}, + {"LightPink2", 238, 162, 173}, + {"LightPink3", 205, 140, 149}, + {"LightPink4", 139, 95, 101}, + {"LightSalmon", 255, 160, 122}, + {"LightSalmon1", 255, 160, 122}, + {"LightSalmon2", 238, 149, 114}, + {"LightSalmon3", 205, 129, 98}, + {"LightSalmon4", 139, 87, 66}, + {"LightSeaGreen", 32, 178, 170}, + {"LightSkyBlue", 135, 206, 250}, + {"LightSkyBlue1", 176, 226, 255}, + {"LightSkyBlue2", 164, 211, 238}, + {"LightSkyBlue3", 141, 182, 205}, + {"LightSkyBlue4", 96, 123, 139}, + {"LightSlateBlue", 132, 112, 255}, + {"LightSlateGray", 119, 136, 153}, + {"LightSlateGrey", 119, 136, 153}, + {"LightSteelBlue", 176, 196, 222}, + {"LightSteelBlue1", 202, 225, 255}, + {"LightSteelBlue2", 188, 210, 238}, + {"LightSteelBlue3", 162, 181, 205}, + {"LightSteelBlue4", 110, 123, 139}, + {"LightYellow", 255, 255, 224}, + {"LightYellow1", 255, 255, 224}, + {"LightYellow2", 238, 238, 209}, + {"LightYellow3", 205, 205, 180}, + {"LightYellow4", 139, 139, 122}, + {"LimeGreen", 50, 205, 50}, + {"MediumAquamarine", 102, 205, 170}, + {"MediumBlue", 0, 0, 205}, + {"MediumOrchid", 186, 85, 211}, + {"MediumOrchid1", 224, 102, 255}, + {"MediumOrchid2", 209, 95, 238}, + {"MediumOrchid3", 180, 82, 205}, + {"MediumOrchid4", 122, 55, 139}, + {"MediumPurple", 147, 112, 219}, + {"MediumPurple1", 171, 130, 255}, + {"MediumPurple2", 159, 121, 238}, + {"MediumPurple3", 137, 104, 205}, + {"MediumPurple4", 93, 71, 139}, + {"MediumSeaGreen", 60, 179, 113}, + {"MediumSlateBlue", 123, 104, 238}, + {"MediumSpringGreen", 0, 250, 154}, + {"MediumTurquoise", 72, 209, 204}, + {"MediumVioletRed", 199, 21, 133}, + {"MidnightBlue", 25, 25, 112}, + {"MintCream", 245, 255, 250}, + {"MistyRose", 255, 228, 225}, + {"MistyRose1", 255, 228, 225}, + {"MistyRose2", 238, 213, 210}, + {"MistyRose3", 205, 183, 181}, + {"MistyRose4", 139, 125, 123}, + {"NavajoWhite", 255, 222, 173}, + {"NavajoWhite1", 255, 222, 173}, + {"NavajoWhite2", 238, 207, 161}, + {"NavajoWhite3", 205, 179, 139}, + {"NavajoWhite4", 139, 121, 94}, + {"NavyBlue", 0, 0, 128}, + {"OldLace", 253, 245, 230}, + {"OliveDrab", 107, 142, 35}, + {"OliveDrab1", 192, 255, 62}, + {"OliveDrab2", 179, 238, 58}, + {"OliveDrab3", 154, 205, 50}, + {"OliveDrab4", 105, 139, 34}, + {"OrangeRed", 255, 69, 0}, + {"OrangeRed1", 255, 69, 0}, + {"OrangeRed2", 238, 64, 0}, + {"OrangeRed3", 205, 55, 0}, + {"OrangeRed4", 139, 37, 0}, + {"PaleGoldenrod", 238, 232, 170}, + {"PaleGreen", 152, 251, 152}, + {"PaleGreen1", 154, 255, 154}, + {"PaleGreen2", 144, 238, 144}, + {"PaleGreen3", 124, 205, 124}, + {"PaleGreen4", 84, 139, 84}, + {"PaleTurquoise", 175, 238, 238}, + {"PaleTurquoise1", 187, 255, 255}, + {"PaleTurquoise2", 174, 238, 238}, + {"PaleTurquoise3", 150, 205, 205}, + {"PaleTurquoise4", 102, 139, 139}, + {"PaleVioletRed", 219, 112, 147}, + {"PaleVioletRed1", 255, 130, 171}, + {"PaleVioletRed2", 238, 121, 159}, + {"PaleVioletRed3", 205, 104, 137}, + {"PaleVioletRed4", 139, 71, 93}, + {"PapayaWhip", 255, 239, 213}, + {"PeachPuff", 255, 218, 185}, + {"PeachPuff1", 255, 218, 185}, + {"PeachPuff2", 238, 203, 173}, + {"PeachPuff3", 205, 175, 149}, + {"PeachPuff4", 139, 119, 101}, + {"PowderBlue", 176, 224, 230}, + {"RosyBrown", 188, 143, 143}, + {"RosyBrown1", 255, 193, 193}, + {"RosyBrown2", 238, 180, 180}, + {"RosyBrown3", 205, 155, 155}, + {"RosyBrown4", 139, 105, 105}, + {"RoyalBlue", 65, 105, 225}, + {"RoyalBlue1", 72, 118, 255}, + {"RoyalBlue2", 67, 110, 238}, + {"RoyalBlue3", 58, 95, 205}, + {"RoyalBlue4", 39, 64, 139}, + {"SaddleBrown", 139, 69, 19}, + {"SandyBrown", 244, 164, 96}, + {"SeaGreen", 46, 139, 87}, + {"SeaGreen1", 84, 255, 159}, + {"SeaGreen2", 78, 238, 148}, + {"SeaGreen3", 67, 205, 128}, + {"SeaGreen4", 46, 139, 87}, + {"SkyBlue", 135, 206, 235}, + {"SkyBlue1", 135, 206, 255}, + {"SkyBlue2", 126, 192, 238}, + {"SkyBlue3", 108, 166, 205}, + {"SkyBlue4", 74, 112, 139}, + {"SlateBlue", 106, 90, 205}, + {"SlateBlue1", 131, 111, 255}, + {"SlateBlue2", 122, 103, 238}, + {"SlateBlue3", 105, 89, 205}, + {"SlateBlue4", 71, 60, 139}, + {"SlateGray", 112, 128, 144}, + {"SlateGray1", 198, 226, 255}, + {"SlateGray2", 185, 211, 238}, + {"SlateGray3", 159, 182, 205}, + {"SlateGray4", 108, 123, 139}, + {"SlateGrey", 112, 128, 144}, + {"SpringGreen", 0, 255, 127}, + {"SpringGreen1", 0, 255, 127}, + {"SpringGreen2", 0, 238, 118}, + {"SpringGreen3", 0, 205, 102}, + {"SpringGreen4", 0, 139, 69}, + {"SteelBlue", 70, 130, 180}, + {"SteelBlue1", 99, 184, 255}, + {"SteelBlue2", 92, 172, 238}, + {"SteelBlue3", 79, 148, 205}, + {"SteelBlue4", 54, 100, 139}, + {"VioletRed", 208, 32, 144}, + {"VioletRed1", 255, 62, 150}, + {"VioletRed2", 238, 58, 140}, + {"VioletRed3", 205, 50, 120}, + {"VioletRed4", 139, 34, 82}, + {"WhiteSmoke", 245, 245, 245}, + {"YellowGreen", 154, 205, 50}, + {"alice blue", 240, 248, 255}, + {"antique white", 250, 235, 215}, + {"aquamarine", 127, 255, 212}, + {"aquamarine1", 127, 255, 212}, + {"aquamarine2", 118, 238, 198}, + {"aquamarine3", 102, 205, 170}, + {"aquamarine4", 69, 139, 116}, + {"azure", 240, 255, 255}, + {"azure1", 240, 255, 255}, + {"azure2", 224, 238, 238}, + {"azure3", 193, 205, 205}, + {"azure4", 131, 139, 139}, + {"beige", 245, 245, 220}, + {"bisque", 255, 228, 196}, + {"bisque1", 255, 228, 196}, + {"bisque2", 238, 213, 183}, + {"bisque3", 205, 183, 158}, + {"bisque4", 139, 125, 107}, + {"black", 0, 0, 0}, + {"blanched almond", 255, 235, 205}, + {"blue", 0, 0, 255}, + {"blue violet", 138, 43, 226}, + {"blue1", 0, 0, 255}, + {"blue2", 0, 0, 238}, + {"blue3", 0, 0, 205}, + {"blue4", 0, 0, 139}, + {"brown", 165, 42, 42}, + {"brown1", 255, 64, 64}, + {"brown2", 238, 59, 59}, + {"brown3", 205, 51, 51}, + {"brown4", 139, 35, 35}, + {"burlywood", 222, 184, 135}, + {"burlywood1", 255, 211, 155}, + {"burlywood2", 238, 197, 145}, + {"burlywood3", 205, 170, 125}, + {"burlywood4", 139, 115, 85}, + {"cadet blue", 95, 158, 160}, + {"chartreuse", 127, 255, 0}, + {"chartreuse1", 127, 255, 0}, + {"chartreuse2", 118, 238, 0}, + {"chartreuse3", 102, 205, 0}, + {"chartreuse4", 69, 139, 0}, + {"chocolate", 210, 105, 30}, + {"chocolate1", 255, 127, 36}, + {"chocolate2", 238, 118, 33}, + {"chocolate3", 205, 102, 29}, + {"chocolate4", 139, 69, 19}, + {"coral", 255, 127, 80}, + {"coral1", 255, 114, 86}, + {"coral2", 238, 106, 80}, + {"coral3", 205, 91, 69}, + {"coral4", 139, 62, 47}, + {"cornflower blue", 100, 149, 237}, + {"cornsilk", 255, 248, 220}, + {"cornsilk1", 255, 248, 220}, + {"cornsilk2", 238, 232, 205}, + {"cornsilk3", 205, 200, 177}, + {"cornsilk4", 139, 136, 120}, + {"cyan", 0, 255, 255}, + {"cyan1", 0, 255, 255}, + {"cyan2", 0, 238, 238}, + {"cyan3", 0, 205, 205}, + {"cyan4", 0, 139, 139}, + {"dark blue", 0, 0, 139}, + {"dark cyan", 0, 139, 139}, + {"dark goldenrod", 184, 134, 11}, + {"dark gray", 169, 169, 169}, + {"dark green", 0, 100, 0}, + {"dark grey", 169, 169, 169}, + {"dark khaki", 189, 183, 107}, + {"dark magenta", 139, 0, 139}, + {"dark olive green", 85, 107, 47}, + {"dark orange", 255, 140, 0}, + {"dark orchid", 153, 50, 204}, + {"dark red", 139, 0, 0}, + {"dark salmon", 233, 150, 122}, + {"dark sea green", 143, 188, 143}, + {"dark slate blue", 72, 61, 139}, + {"dark slate gray", 47, 79, 79}, + {"dark slate grey", 47, 79, 79}, + {"dark turquoise", 0, 206, 209}, + {"dark violet", 148, 0, 211}, + {"deep pink", 255, 20, 147}, + {"deep sky blue", 0, 191, 255}, + {"dim gray", 105, 105, 105}, + {"dim grey", 105, 105, 105}, + {"dodger blue", 30, 144, 255}, + {"firebrick", 178, 34, 34}, + {"firebrick1", 255, 48, 48}, + {"firebrick2", 238, 44, 44}, + {"firebrick3", 205, 38, 38}, + {"firebrick4", 139, 26, 26}, + {"floral white", 255, 250, 240}, + {"forest green", 34, 139, 34}, + {"gainsboro", 220, 220, 220}, + {"ghost white", 248, 248, 255}, + {"gold", 255, 215, 0}, + {"gold1", 255, 215, 0}, + {"gold2", 238, 201, 0}, + {"gold3", 205, 173, 0}, + {"gold4", 139, 117, 0}, + {"goldenrod", 218, 165, 32}, + {"goldenrod1", 255, 193, 37}, + {"goldenrod2", 238, 180, 34}, + {"goldenrod3", 205, 155, 29}, + {"goldenrod4", 139, 105, 20}, + {"gray", 190, 190, 190}, + {"gray0", 0, 0, 0}, + {"gray1", 3, 3, 3}, + {"gray10", 26, 26, 26}, + {"gray100", 255, 255, 255}, + {"gray11", 28, 28, 28}, + {"gray12", 31, 31, 31}, + {"gray13", 33, 33, 33}, + {"gray14", 36, 36, 36}, + {"gray15", 38, 38, 38}, + {"gray16", 41, 41, 41}, + {"gray17", 43, 43, 43}, + {"gray18", 46, 46, 46}, + {"gray19", 48, 48, 48}, + {"gray2", 5, 5, 5}, + {"gray20", 51, 51, 51}, + {"gray21", 54, 54, 54}, + {"gray22", 56, 56, 56}, + {"gray23", 59, 59, 59}, + {"gray24", 61, 61, 61}, + {"gray25", 64, 64, 64}, + {"gray26", 66, 66, 66}, + {"gray27", 69, 69, 69}, + {"gray28", 71, 71, 71}, + {"gray29", 74, 74, 74}, + {"gray3", 8, 8, 8}, + {"gray30", 77, 77, 77}, + {"gray31", 79, 79, 79}, + {"gray32", 82, 82, 82}, + {"gray33", 84, 84, 84}, + {"gray34", 87, 87, 87}, + {"gray35", 89, 89, 89}, + {"gray36", 92, 92, 92}, + {"gray37", 94, 94, 94}, + {"gray38", 97, 97, 97}, + {"gray39", 99, 99, 99}, + {"gray4", 10, 10, 10}, + {"gray40", 102, 102, 102}, + {"gray41", 105, 105, 105}, + {"gray42", 107, 107, 107}, + {"gray43", 110, 110, 110}, + {"gray44", 112, 112, 112}, + {"gray45", 115, 115, 115}, + {"gray46", 117, 117, 117}, + {"gray47", 120, 120, 120}, + {"gray48", 122, 122, 122}, + {"gray49", 125, 125, 125}, + {"gray5", 13, 13, 13}, + {"gray50", 127, 127, 127}, + {"gray51", 130, 130, 130}, + {"gray52", 133, 133, 133}, + {"gray53", 135, 135, 135}, + {"gray54", 138, 138, 138}, + {"gray55", 140, 140, 140}, + {"gray56", 143, 143, 143}, + {"gray57", 145, 145, 145}, + {"gray58", 148, 148, 148}, + {"gray59", 150, 150, 150}, + {"gray6", 15, 15, 15}, + {"gray60", 153, 153, 153}, + {"gray61", 156, 156, 156}, + {"gray62", 158, 158, 158}, + {"gray63", 161, 161, 161}, + {"gray64", 163, 163, 163}, + {"gray65", 166, 166, 166}, + {"gray66", 168, 168, 168}, + {"gray67", 171, 171, 171}, + {"gray68", 173, 173, 173}, + {"gray69", 176, 176, 176}, + {"gray7", 18, 18, 18}, + {"gray70", 179, 179, 179}, + {"gray71", 181, 181, 181}, + {"gray72", 184, 184, 184}, + {"gray73", 186, 186, 186}, + {"gray74", 189, 189, 189}, + {"gray75", 191, 191, 191}, + {"gray76", 194, 194, 194}, + {"gray77", 196, 196, 196}, + {"gray78", 199, 199, 199}, + {"gray79", 201, 201, 201}, + {"gray8", 20, 20, 20}, + {"gray80", 204, 204, 204}, + {"gray81", 207, 207, 207}, + {"gray82", 209, 209, 209}, + {"gray83", 212, 212, 212}, + {"gray84", 214, 214, 214}, + {"gray85", 217, 217, 217}, + {"gray86", 219, 219, 219}, + {"gray87", 222, 222, 222}, + {"gray88", 224, 224, 224}, + {"gray89", 227, 227, 227}, + {"gray9", 23, 23, 23}, + {"gray90", 229, 229, 229}, + {"gray91", 232, 232, 232}, + {"gray92", 235, 235, 235}, + {"gray93", 237, 237, 237}, + {"gray94", 240, 240, 240}, + {"gray95", 242, 242, 242}, + {"gray96", 245, 245, 245}, + {"gray97", 247, 247, 247}, + {"gray98", 250, 250, 250}, + {"gray99", 252, 252, 252}, + {"green", 0, 255, 0}, + {"green yellow", 173, 255, 47}, + {"green1", 0, 255, 0}, + {"green2", 0, 238, 0}, + {"green3", 0, 205, 0}, + {"green4", 0, 139, 0}, + {"grey", 190, 190, 190}, + {"grey0", 0, 0, 0}, + {"grey1", 3, 3, 3}, + {"grey10", 26, 26, 26}, + {"grey100", 255, 255, 255}, + {"grey11", 28, 28, 28}, + {"grey12", 31, 31, 31}, + {"grey13", 33, 33, 33}, + {"grey14", 36, 36, 36}, + {"grey15", 38, 38, 38}, + {"grey16", 41, 41, 41}, + {"grey17", 43, 43, 43}, + {"grey18", 46, 46, 46}, + {"grey19", 48, 48, 48}, + {"grey2", 5, 5, 5}, + {"grey20", 51, 51, 51}, + {"grey21", 54, 54, 54}, + {"grey22", 56, 56, 56}, + {"grey23", 59, 59, 59}, + {"grey24", 61, 61, 61}, + {"grey25", 64, 64, 64}, + {"grey26", 66, 66, 66}, + {"grey27", 69, 69, 69}, + {"grey28", 71, 71, 71}, + {"grey29", 74, 74, 74}, + {"grey3", 8, 8, 8}, + {"grey30", 77, 77, 77}, + {"grey31", 79, 79, 79}, + {"grey32", 82, 82, 82}, + {"grey33", 84, 84, 84}, + {"grey34", 87, 87, 87}, + {"grey35", 89, 89, 89}, + {"grey36", 92, 92, 92}, + {"grey37", 94, 94, 94}, + {"grey38", 97, 97, 97}, + {"grey39", 99, 99, 99}, + {"grey4", 10, 10, 10}, + {"grey40", 102, 102, 102}, + {"grey41", 105, 105, 105}, + {"grey42", 107, 107, 107}, + {"grey43", 110, 110, 110}, + {"grey44", 112, 112, 112}, + {"grey45", 115, 115, 115}, + {"grey46", 117, 117, 117}, + {"grey47", 120, 120, 120}, + {"grey48", 122, 122, 122}, + {"grey49", 125, 125, 125}, + {"grey5", 13, 13, 13}, + {"grey50", 127, 127, 127}, + {"grey51", 130, 130, 130}, + {"grey52", 133, 133, 133}, + {"grey53", 135, 135, 135}, + {"grey54", 138, 138, 138}, + {"grey55", 140, 140, 140}, + {"grey56", 143, 143, 143}, + {"grey57", 145, 145, 145}, + {"grey58", 148, 148, 148}, + {"grey59", 150, 150, 150}, + {"grey6", 15, 15, 15}, + {"grey60", 153, 153, 153}, + {"grey61", 156, 156, 156}, + {"grey62", 158, 158, 158}, + {"grey63", 161, 161, 161}, + {"grey64", 163, 163, 163}, + {"grey65", 166, 166, 166}, + {"grey66", 168, 168, 168}, + {"grey67", 171, 171, 171}, + {"grey68", 173, 173, 173}, + {"grey69", 176, 176, 176}, + {"grey7", 18, 18, 18}, + {"grey70", 179, 179, 179}, + {"grey71", 181, 181, 181}, + {"grey72", 184, 184, 184}, + {"grey73", 186, 186, 186}, + {"grey74", 189, 189, 189}, + {"grey75", 191, 191, 191}, + {"grey76", 194, 194, 194}, + {"grey77", 196, 196, 196}, + {"grey78", 199, 199, 199}, + {"grey79", 201, 201, 201}, + {"grey8", 20, 20, 20}, + {"grey80", 204, 204, 204}, + {"grey81", 207, 207, 207}, + {"grey82", 209, 209, 209}, + {"grey83", 212, 212, 212}, + {"grey84", 214, 214, 214}, + {"grey85", 217, 217, 217}, + {"grey86", 219, 219, 219}, + {"grey87", 222, 222, 222}, + {"grey88", 224, 224, 224}, + {"grey89", 227, 227, 227}, + {"grey9", 23, 23, 23}, + {"grey90", 229, 229, 229}, + {"grey91", 232, 232, 232}, + {"grey92", 235, 235, 235}, + {"grey93", 237, 237, 237}, + {"grey94", 240, 240, 240}, + {"grey95", 242, 242, 242}, + {"grey96", 245, 245, 245}, + {"grey97", 247, 247, 247}, + {"grey98", 250, 250, 250}, + {"grey99", 252, 252, 252}, + {"honeydew", 240, 255, 240}, + {"honeydew1", 240, 255, 240}, + {"honeydew2", 224, 238, 224}, + {"honeydew3", 193, 205, 193}, + {"honeydew4", 131, 139, 131}, + {"hot pink", 255, 105, 180}, + {"indian red", 205, 92, 92}, + {"ivory", 255, 255, 240}, + {"ivory1", 255, 255, 240}, + {"ivory2", 238, 238, 224}, + {"ivory3", 205, 205, 193}, + {"ivory4", 139, 139, 131}, + {"khaki", 240, 230, 140}, + {"khaki1", 255, 246, 143}, + {"khaki2", 238, 230, 133}, + {"khaki3", 205, 198, 115}, + {"khaki4", 139, 134, 78}, + {"lavender", 230, 230, 250}, + {"lavender blush", 255, 240, 245}, + {"lawn green", 124, 252, 0}, + {"lemon chiffon", 255, 250, 205}, + {"light blue", 173, 216, 230}, + {"light coral", 240, 128, 128}, + {"light cyan", 224, 255, 255}, + {"light goldenrod", 238, 221, 130}, + {"light goldenrod yellow", 250, 250, 210}, + {"light gray", 211, 211, 211}, + {"light green", 144, 238, 144}, + {"light grey", 211, 211, 211}, + {"light pink", 255, 182, 193}, + {"light salmon", 255, 160, 122}, + {"light sea green", 32, 178, 170}, + {"light sky blue", 135, 206, 250}, + {"light slate blue", 132, 112, 255}, + {"light slate gray", 119, 136, 153}, + {"light slate grey", 119, 136, 153}, + {"light steel blue", 176, 196, 222}, + {"light yellow", 255, 255, 224}, + {"lime green", 50, 205, 50}, + {"linen", 250, 240, 230}, + {"magenta", 255, 0, 255}, + {"magenta1", 255, 0, 255}, + {"magenta2", 238, 0, 238}, + {"magenta3", 205, 0, 205}, + {"magenta4", 139, 0, 139}, + {"maroon", 176, 48, 96}, + {"maroon1", 255, 52, 179}, + {"maroon2", 238, 48, 167}, + {"maroon3", 205, 41, 144}, + {"maroon4", 139, 28, 98}, + {"medium aquamarine", 102, 205, 170}, + {"medium blue", 0, 0, 205}, + {"medium orchid", 186, 85, 211}, + {"medium purple", 147, 112, 219}, + {"medium sea green", 60, 179, 113}, + {"medium slate blue", 123, 104, 238}, + {"medium spring green", 0, 250, 154}, + {"medium turquoise", 72, 209, 204}, + {"medium violet red", 199, 21, 133}, + {"midnight blue", 25, 25, 112}, + {"mint cream", 245, 255, 250}, + {"misty rose", 255, 228, 225}, + {"moccasin", 255, 228, 181}, + {"navajo white", 255, 222, 173}, + {"navy", 0, 0, 128}, + {"navy blue", 0, 0, 128}, + {"old lace", 253, 245, 230}, + {"olive drab", 107, 142, 35}, + {"orange", 255, 165, 0}, + {"orange red", 255, 69, 0}, + {"orange1", 255, 165, 0}, + {"orange2", 238, 154, 0}, + {"orange3", 205, 133, 0}, + {"orange4", 139, 90, 0}, + {"orchid", 218, 112, 214}, + {"orchid1", 255, 131, 250}, + {"orchid2", 238, 122, 233}, + {"orchid3", 205, 105, 201}, + {"orchid4", 139, 71, 137}, + {"pale goldenrod", 238, 232, 170}, + {"pale green", 152, 251, 152}, + {"pale turquoise", 175, 238, 238}, + {"pale violet red", 219, 112, 147}, + {"papaya whip", 255, 239, 213}, + {"peach puff", 255, 218, 185}, + {"peru", 205, 133, 63}, + {"pink", 255, 192, 203}, + {"pink1", 255, 181, 197}, + {"pink2", 238, 169, 184}, + {"pink3", 205, 145, 158}, + {"pink4", 139, 99, 108}, + {"plum", 221, 160, 221}, + {"plum1", 255, 187, 255}, + {"plum2", 238, 174, 238}, + {"plum3", 205, 150, 205}, + {"plum4", 139, 102, 139}, + {"powder blue", 176, 224, 230}, + {"purple", 160, 32, 240}, + {"purple1", 155, 48, 255}, + {"purple2", 145, 44, 238}, + {"purple3", 125, 38, 205}, + {"purple4", 85, 26, 139}, + {"red", 255, 0, 0}, + {"red1", 255, 0, 0}, + {"red2", 238, 0, 0}, + {"red3", 205, 0, 0}, + {"red4", 139, 0, 0}, + {"rosy brown", 188, 143, 143}, + {"royal blue", 65, 105, 225}, + {"saddle brown", 139, 69, 19}, + {"salmon", 250, 128, 114}, + {"salmon1", 255, 140, 105}, + {"salmon2", 238, 130, 98}, + {"salmon3", 205, 112, 84}, + {"salmon4", 139, 76, 57}, + {"sandy brown", 244, 164, 96}, + {"sea green", 46, 139, 87}, + {"seashell", 255, 245, 238}, + {"seashell1", 255, 245, 238}, + {"seashell2", 238, 229, 222}, + {"seashell3", 205, 197, 191}, + {"seashell4", 139, 134, 130}, + {"sienna", 160, 82, 45}, + {"sienna1", 255, 130, 71}, + {"sienna2", 238, 121, 66}, + {"sienna3", 205, 104, 57}, + {"sienna4", 139, 71, 38}, + {"sky blue", 135, 206, 235}, + {"slate blue", 106, 90, 205}, + {"slate gray", 112, 128, 144}, + {"slate grey", 112, 128, 144}, + {"snow", 255, 250, 250}, + {"snow1", 255, 250, 250}, + {"snow2", 238, 233, 233}, + {"snow3", 205, 201, 201}, + {"snow4", 139, 137, 137}, + {"spring green", 0, 255, 127}, + {"steel blue", 70, 130, 180}, + {"tan", 210, 180, 140}, + {"tan1", 255, 165, 79}, + {"tan2", 238, 154, 73}, + {"tan3", 205, 133, 63}, + {"tan4", 139, 90, 43}, + {"thistle", 216, 191, 216}, + {"thistle1", 255, 225, 255}, + {"thistle2", 238, 210, 238}, + {"thistle3", 205, 181, 205}, + {"thistle4", 139, 123, 139}, + {"tomato", 255, 99, 71}, + {"tomato1", 255, 99, 71}, + {"tomato2", 238, 92, 66}, + {"tomato3", 205, 79, 57}, + {"tomato4", 139, 54, 38}, + {"turquoise", 64, 224, 208}, + {"turquoise1", 0, 245, 255}, + {"turquoise2", 0, 229, 238}, + {"turquoise3", 0, 197, 205}, + {"turquoise4", 0, 134, 139}, + {"violet", 238, 130, 238}, + {"violet red", 208, 32, 144}, + {"wheat", 245, 222, 179}, + {"wheat1", 255, 231, 186}, + {"wheat2", 238, 216, 174}, + {"wheat3", 205, 186, 150}, + {"wheat4", 139, 126, 102}, + {"white", 255, 255, 255}, + {"white smoke", 245, 245, 245}, + {"yellow", 255, 255, 0}, + {"yellow green", 154, 205, 50}, + {"yellow1", 255, 255, 0}, + {"yellow2", 238, 238, 0}, + {"yellow3", 205, 205, 0}, + {"yellow4", 139, 139, 0}, +}; + +BGD_EXPORT_DATA_PROT gdColorMap GD_COLOR_MAP_X11 = { + sizeof(GD_COLOR_MAP_X11_ENTRIES)/sizeof(gdColorMapEntry), + (gdColorMapEntry *)GD_COLOR_MAP_X11_ENTRIES +}; + +BGD_DECLARE(int) +gdColorMapLookup(const gdColorMap color_map, const char *color_name, int *r, int *g, int *b) +{ + gdColorMapEntry *entries = color_map.entries; + int low = 0; + int high = color_map.num_entries - 1; + while (low <= high) { + int i = (low+high)/2; + int result = strcmp(color_name, entries[i].color_name); + if (result == 0) { + *r = entries[i].red; + *g = entries[i].green; + *b = entries[i].blue; + return 1; + } else if (result < 0) { + high = i - 1; + } else { + low = i + 1; + } + } + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_color_map.h b/Build/source/libs/gd/libgd-2.1.1/src/gd_color_map.h new file mode 100644 index 00000000000..6d2275e5647 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_color_map.h @@ -0,0 +1,30 @@ +#ifndef GD_COLOR_MAP_H +#define GD_COLOR_MAP_H 1 + +#include "gd.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + char *color_name; + int red; + int green; + int blue; +} gdColorMapEntry; + +typedef struct { + int num_entries; + gdColorMapEntry *entries; +} gdColorMap; + +extern BGD_EXPORT_DATA_PROT gdColorMap GD_COLOR_MAP_X11; + +BGD_DECLARE(int) gdColorMapLookup(const gdColorMap color_map, const char *color_name, int *r, int *g, int *b); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_color_map_test.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_color_map_test.c new file mode 100644 index 00000000000..26e08bd8516 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_color_map_test.c @@ -0,0 +1,27 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include "gd.h" +#include "gd_color_map.h" + +int +main(void) +{ + int r, g, b; + int i; + for (i=0; i<GD_COLOR_MAP_X11.num_entries; i++) { + char *color_name = GD_COLOR_MAP_X11.entries[i].color_name; + if (gdColorMapLookup(GD_COLOR_MAP_X11, color_name, &r, &g, &b)) { + printf("%s found: #%02x%02x%02x\n", color_name, r, g, b); + } else { + fprintf(stderr, "%s not found\n", color_name); + return 1; + } + } + if (gdColorMapLookup(GD_COLOR_MAP_X11, "no such name", &r, &g, &b)) { + return 2; + } + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_color_match.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_color_match.c new file mode 100644 index 00000000000..5f0fd0a86c2 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_color_match.c @@ -0,0 +1,61 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include <string.h> +#include "gd.h" +#include "gdhelpers.h" + +/* bring the palette colors in im2 to be closer to im1 + * + */ +BGD_DECLARE(int) gdImageColorMatch (gdImagePtr im1, gdImagePtr im2) +{ + unsigned long *buf; /* stores our calculations */ + unsigned long *bp; /* buf ptr */ + int color, rgb; + int x,y; + int count; + + if (!im1->trueColor) { + return -1; /* im1 must be True Color */ + } + if (im2->trueColor) { + return -2; /* im2 must be indexed */ + } + if ((im1->sx != im2->sx) || (im1->sy != im2->sy)) { + return -3; /* the images are meant to be the same dimensions */ + } + if (im2->colorsTotal < 1) { + return -4; /* At least 1 color must be allocated */ + } + + buf = (unsigned long *)gdMalloc(sizeof(unsigned long) * 5 * im2->colorsTotal); + memset (buf, 0, sizeof(unsigned long) * 5 * im2->colorsTotal ); + + for (x=0; x < im1->sx; x++) { + for( y=0; y<im1->sy; y++ ) { + color = im2->pixels[y][x]; + rgb = im1->tpixels[y][x]; + bp = buf + (color * 5); + (*(bp++))++; + *(bp++) += gdTrueColorGetRed(rgb); + *(bp++) += gdTrueColorGetGreen(rgb); + *(bp++) += gdTrueColorGetBlue(rgb); + *(bp++) += gdTrueColorGetAlpha(rgb); + } + } + bp = buf; + for (color=0; color < im2->colorsTotal; color++) { + count = *(bp++); + if( count > 0 ) { + im2->red[color] = *(bp++) / count; + im2->green[color] = *(bp++) / count; + im2->blue[color] = *(bp++) / count; + im2->alpha[color] = *(bp++) / count; + } else { + bp += 4; + } + } + gdFree(buf); + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_crop.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_crop.c new file mode 100644 index 00000000000..02966336d18 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_crop.c @@ -0,0 +1,235 @@ +/* Crop support + * manual crop using a gdRect or automatic crop using a background + * color (automatic detections or using either the transparent color, + * black or white). + * An alternative method allows to crop using a given color and a + * threshold. It works relatively well but it can be improved. + * Maybe L*a*b* and Delta-E will give better results (and a better + * granularity). + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdlib.h> +#include "gd.h" +#include "gd_color.h" + +static int gdGuessBackgroundColorFromCorners(gdImagePtr im, int *color); + +BGD_DECLARE(gdImagePtr) gdImageCrop(gdImagePtr src, const gdRect *crop) +{ + gdImagePtr dst; + + dst = gdImageCreateTrueColor(crop->width, crop->height); + if (!dst) return NULL; + gdImageCopy(dst, src, 0, 0, crop->x, crop->y, crop->width, crop->height); + + return dst; +} + +BGD_DECLARE(gdImagePtr) gdImageCropAuto(gdImagePtr im, const unsigned int mode) +{ + const int width = gdImageSX(im); + const int height = gdImageSY(im); + + int x,y; + int color, match; + gdRect crop; + + crop.x = 0; + crop.y = 0; + crop.width = 0; + crop.height = 0; + + switch (mode) { + case GD_CROP_TRANSPARENT: + color = gdImageGetTransparent(im); + break; + + case GD_CROP_BLACK: + color = gdImageColorClosestAlpha(im, 0, 0, 0, 0); + break; + + case GD_CROP_WHITE: + color = gdImageColorClosestAlpha(im, 255, 255, 255, 0); + break; + + case GD_CROP_SIDES: + gdGuessBackgroundColorFromCorners(im, &color); + break; + + case GD_CROP_DEFAULT: + default: + color = gdImageGetTransparent(im); + break; + } + + /* TODO: Add gdImageGetRowPtr and works with ptr at the row level + * for the true color and palette images + * new formats will simply work with ptr + */ + match = 1; + for (y = 0; match && y < height; y++) { + for (x = 0; match && x < width; x++) { + match = (color == gdImageGetPixel(im, x,y)); + } + } + + /* Nothing to do > bye + * Duplicate the image? + */ + if (y == height - 1) { + return NULL; + } + + crop.y = y -1; + match = 1; + for (y = height - 1; match && y >= 0; y--) { + for (x = 0; match && x < width; x++) { + match = (color == gdImageGetPixel(im, x,y)); + } + } + + if (y == 0) { + crop.height = height - crop.y + 1; + } else { + crop.height = y - crop.y + 2; + } + + match = 1; + for (x = 0; match && x < width; x++) { + for (y = 0; match && y < crop.y + crop.height - 1; y++) { + match = (color == gdImageGetPixel(im, x,y)); + } + } + crop.x = x - 1; + + match = 1; + for (x = width - 1; match && x >= 0; x--) { + for (y = 0; match && y < crop.y + crop.height - 1; y++) { + match = (color == gdImageGetPixel(im, x,y)); + } + } + crop.width = x - crop.x + 2; + + return gdImageCrop(im, &crop); +} + +BGD_DECLARE(gdImagePtr) gdImageCropThreshold(gdImagePtr im, const unsigned int color, const float threshold) +{ + const int width = gdImageSX(im); + const int height = gdImageSY(im); + + int x,y; + int match; + gdRect crop; + + crop.x = 0; + crop.y = 0; + crop.width = 0; + crop.height = 0; + + /* Pierre: crop everything sounds bad */ + if (threshold > 100.0) { + return NULL; + } + + /* TODO: Add gdImageGetRowPtr and works with ptr at the row level + * for the true color and palette images + * new formats will simply work with ptr + */ + match = 1; + for (y = 0; match && y < height; y++) { + for (x = 0; match && x < width; x++) { + match = (gdColorMatch(im, color, gdImageGetPixel(im, x,y), threshold)) > 0; + } + } + + /* Pierre + * Nothing to do > bye + * Duplicate the image? + */ + if (y == height - 1) { + return NULL; + } + + crop.y = y -1; + match = 1; + for (y = height - 1; match && y >= 0; y--) { + for (x = 0; match && x < width; x++) { + match = (gdColorMatch(im, color, gdImageGetPixel(im, x, y), threshold)) > 0; + } + } + + if (y == 0) { + crop.height = height - crop.y + 1; + } else { + crop.height = y - crop.y + 2; + } + + match = 1; + for (x = 0; match && x < width; x++) { + for (y = 0; match && y < crop.y + crop.height - 1; y++) { + match = (gdColorMatch(im, color, gdImageGetPixel(im, x,y), threshold)) > 0; + } + } + crop.x = x - 1; + + match = 1; + for (x = width - 1; match && x >= 0; x--) { + for (y = 0; match && y < crop.y + crop.height - 1; y++) { + match = (gdColorMatch(im, color, gdImageGetPixel(im, x,y), threshold)) > 0; + } + } + crop.width = x - crop.x + 2; + + return gdImageCrop(im, &crop); +} + +/* This algorithm comes from pnmcrop (http://netpbm.sourceforge.net/) + * Three steps: + * - if 3 corners are equal. + * - if two are equal. + * - Last solution: average the colors + */ +static int gdGuessBackgroundColorFromCorners(gdImagePtr im, int *color) +{ + const int tl = gdImageGetPixel(im, 0, 0); + const int tr = gdImageGetPixel(im, gdImageSX(im) - 1, 0); + const int bl = gdImageGetPixel(im, 0, gdImageSY(im) -1); + const int br = gdImageGetPixel(im, gdImageSX(im) - 1, gdImageSY(im) -1); + + if (tr == bl && tr == br) { + *color = tr; + return 3; + } else if (tl == bl && tl == br) { + *color = tl; + return 3; + } else if (tl == tr && tl == br) { + *color = tl; + return 3; + } else if (tl == tr && tl == bl) { + *color = tl; + return 3; + } else if (tl == tr || tl == bl || tl == br) { + *color = tl; + return 2; + } else if (tr == bl) { + *color = tr; + return 2; + } else if (br == bl) { + *color = bl; + return 2; + } else { + register int r,b,g,a; + + r = (int)(0.5f + (gdImageRed(im, tl) + gdImageRed(im, tr) + gdImageRed(im, bl) + gdImageRed(im, br)) / 4); + g = (int)(0.5f + (gdImageGreen(im, tl) + gdImageGreen(im, tr) + gdImageGreen(im, bl) + gdImageGreen(im, br)) / 4); + b = (int)(0.5f + (gdImageBlue(im, tl) + gdImageBlue(im, tr) + gdImageBlue(im, bl) + gdImageBlue(im, br)) / 4); + a = (int)(0.5f + (gdImageAlpha(im, tl) + gdImageAlpha(im, tr) + gdImageAlpha(im, bl) + gdImageAlpha(im, br)) / 4); + *color = gdImageColorClosestAlpha(im, r, g, b, a); + return 0; + } +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_errors.h b/Build/source/libs/gd/libgd-2.1.1/src/gd_errors.h new file mode 100644 index 00000000000..4ecee94b386 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_errors.h @@ -0,0 +1,46 @@ +#ifndef GD_ERRORS_H +#define GD_ERRORS_H + +#ifndef _WIN32 +# include <syslog.h> +#else +/* + * priorities/facilities are encoded into a single 32-bit quantity, where the + * bottom 3 bits are the priority (0-7) and the top 28 bits are the facility + * (0-big number). Both the priorities and the facilities map roughly + * one-to-one to strings in the syslogd(8) source code. This mapping is + * included in this file. + * + * priorities (these are ordered) + */ +# define LOG_EMERG 0 /* system is unusable */ +# define LOG_ALERT 1 /* action must be taken immediately */ +# define LOG_CRIT 2 /* critical conditions */ +# define LOG_ERR 3 /* error conditions */ +# define LOG_WARNING 4 /* warning conditions */ +# define LOG_NOTICE 5 /* normal but significant condition */ +# define LOG_INFO 6 /* informational */ +# define LOG_DEBUG 7 /* debug-level messages */ +#endif + +/* +LOG_EMERG system is unusable +LOG_ALERT action must be taken immediately +LOG_CRIT critical conditions +LOG_ERR error conditions +LOG_WARNING warning conditions +LOG_NOTICE normal, but significant, condition +LOG_INFO informational message +LOG_DEBUG debug-level message +*/ + +#define GD_ERROR LOG_ERR +#define GD_WARNING LOG_WARNING +#define GD_NOTICE LOG_NOTICE +#define GD_INFO LOG_INFO +#define GD_DEBUG LOG_DEBUG + +void gd_error(const char *format, ...); +void gd_error_ex(int priority, const char *format, ...); + +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_filename.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_filename.c new file mode 100644 index 00000000000..ba636cfe0e7 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_filename.c @@ -0,0 +1,254 @@ +/* Convenience functions to read or write images from or to disk, + * determining file type from the filename extension. */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <stdio.h> +#include <string.h> + +#include "gd.h" + +typedef gdImagePtr (BGD_STDCALL *ReadFn)(FILE *in); +typedef void (BGD_STDCALL *WriteFn)(gdImagePtr im, FILE *out); +typedef gdImagePtr (BGD_STDCALL *LoadFn)(char *filename); + +#ifdef HAVE_LIBZ +static void BGD_STDCALL writegd2(gdImagePtr im, FILE *out) { + gdImageGd2(im, out, 0, GD2_FMT_COMPRESSED); +}/* writegd*/ +#endif + +#ifdef HAVE_LIBJPEG +static void BGD_STDCALL writejpeg(gdImagePtr im, FILE *out) { + gdImageJpeg(im, out, -1); +}/* writejpeg*/ +#endif + +static void BGD_STDCALL writewbmp(gdImagePtr im, FILE *out) { + int fg = gdImageColorClosest(im, 0, 0, 0); + + gdImageWBMP(im, fg, out); +}/* writejpeg*/ + +static void BGD_STDCALL writebmp(gdImagePtr im, FILE *out) { + gdImageBmp(im, out, GD_TRUE); +}/* writejpeg*/ + + +enum FType {UNKNOWN, PNG, JPG, GIF, TIFF, GD, GD2, WEBP}; +static struct FileType { + const char *ext; + ReadFn reader; + WriteFn writer; + LoadFn loader; +} Types[] = { + {".gif", gdImageCreateFromGif, gdImageGif, NULL}, + {".gd", gdImageCreateFromGd, gdImageGd, NULL}, + {".wbmp", gdImageCreateFromWBMP, writewbmp, NULL}, + {".bmp", gdImageCreateFromBmp, writebmp, NULL}, + + {".xbm", gdImageCreateFromXbm, NULL, NULL}, + {".tga", gdImageCreateFromTga, NULL, NULL}, + +#ifdef HAVE_LIBPNG + {".png", gdImageCreateFromPng, gdImagePng, NULL}, +#endif + +#ifdef HAVE_LIBJPEG + {".jpg", gdImageCreateFromJpeg, writejpeg, NULL}, + {".jpeg", gdImageCreateFromJpeg, writejpeg, NULL}, +#endif + +#ifdef HAVE_LIBTIFF + {".tiff", gdImageCreateFromTiff, gdImageTiff, NULL}, + {".tif" , gdImageCreateFromTiff, gdImageTiff, NULL}, +#endif + +#ifdef HAVE_LIBZ + {".gd2", gdImageCreateFromGd2, writegd2, NULL}, +#endif + +#ifdef HAVE_LIBVPX + {".webp", gdImageCreateFromWebp, gdImageWebp, NULL}, +#endif + +#ifdef HAVE_LIBXPM + {".xpm", NULL, NULL, gdImageCreateFromXpm}, +#endif + + {NULL, NULL, NULL} +}; + + +struct FileType * +ftype(const char *filename) { + int n; + char *ext; + + /* Find the file extension (i.e. the last period in the string. */ + ext = strrchr(filename, '.'); + if (!ext) return NULL; + + for (n = 0; Types[n].ext; n++) { + if (strcasecmp(ext, Types[n].ext) == 0) { + return &Types[n]; + }/* if */ + }/* for */ + + return NULL; +}/* ftype*/ + + +/* + Function: gdSupportsFileType + + Tests if a given file type is supported by GD. + + Given the name of an image file (which does not have to exist), + returns 1 (i.e. TRUE) if <gdImageCreateFromFile> can read a file + of that type. This is useful if you do not know which image types + were enabled at compile time. + + If _writing_ is true, the result will be true only if + <gdImageFile> can write a file of this type. + + Note that filename parsing is done exactly the same as is done by + <gdImageCreateFromFile> and <gdImageFile> and is subject to the + same limitations. + + Assuming LibGD is compiled with support for these image types, the + following extensions are supported: + + - .gif + - .gd, .gd2 + - .wbmp + - .bmp + - .xbm + - .tga + - .png + - .jpg, .jpeg + - .tiff, .tif + - .webp + - .xpm + + Names are parsed case-insenstively. + + Parameters: + + filename - Filename with tested extension. + writing - Flag: true tests if writing works + + Returns: + + GD_TRUE (1) if the file type is supported, GD_FALSE (0) if not. + +*/ +BGD_DECLARE(int) +gdSupportsFileType(const char *filename, int writing) { + struct FileType *entry = ftype(filename); + return !!entry && (!writing || !!entry->writer); +}/* gdSupportsFileType*/ + + +/* + Function: gdImageCreateFromFile + + Read an image file of any supported. + + Given the path to a file, <gdImageCreateFromFile> will open the + file, read its contents with the appropriate _gdImageCreateFrom*_ + function and return it. + + File type is determined by the filename extension, so having an + incorrect extension will probably not work. For example, renaming + PNG image "foo.png" to "foo.gif" and then attempting to load it + will fail even if GD supports both formats. See + <gdSupportsFiletype> for more details. + + NULL is returned on error. + + Parameters: + + filename - the input file name + + Returns: + + A pointer to the new image or NULL if an error occurred. + +*/ + +BGD_DECLARE(gdImagePtr) +gdImageCreateFromFile(const char *filename) { + struct FileType *entry = ftype(filename); + FILE *fh; + gdImagePtr result; + + if (!entry) return NULL; + if (entry->loader) return entry->loader((char *)filename); + if (!entry->reader) return NULL; + + fh = fopen(filename, "rb"); + if (!fh) return NULL; + + result = entry->reader(fh); + + fclose(fh); + + return result; +}/* gdImageCreateFromFile*/ + + + +/* + Function: gdImageFile + + Writes an image to a file in the format indicated by the filename. + + File type is determined by the extension of the file name. See + <gdSupportsFiletype> for an overview of the parsing. + + For file types that require extra arguments, <gdImageFile> + attempts to use sane defaults: + + <gdImageGd2> - chunk size = 0, compression is enabled. + <gdImageJpeg> - quality = -1 (i.e. the reasonable default) + <gdImageWBMP> - foreground is the darkest available color + + Everything else is called with the two-argument function and so + will use the default values. + + <gdImageFile> has some rudimentary error detection and will return + GD_FALSE (0) if a detectable error occurred. However, the image + loaders do not normally return their error status so a result of + GD_TRUE (1) does **not** mean the file was saved successfully. + + Parameters: + + im - The image to save. + filename - The path to the file to which the image is saved. + + Returns: + + GD_FALSE (0) if an error was detected, GD_TRUE (1) if not. + +*/ + +BGD_DECLARE(int) +gdImageFile(gdImagePtr im, const char *filename) { + struct FileType *entry = ftype(filename); + FILE *fh; + + if (!entry || !entry->writer) return GD_FALSE; + + fh = fopen(filename, "wb"); + if (!fh) return GD_FALSE; + + entry->writer(im, fh); + + fclose(fh); + + return GD_TRUE; +}/* gdImageFile*/ + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_filter.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_filter.c new file mode 100644 index 00000000000..a3119f77f80 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_filter.c @@ -0,0 +1,863 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gd.h" +#include "gdhelpers.h" +#include "gd_intern.h" + +#ifdef _WIN32 +# include <windows.h> +#else +# include <unistd.h> +#endif +#include <stdlib.h> +#include <time.h> +#include <math.h> + +#define NDEBUG /* Uncomment to enable assertions. */ +#include <assert.h> + +typedef int (BGD_STDCALL *FuncPtr)(gdImagePtr, int, int); + +#define GET_PIXEL_FUNCTION(src)(src->trueColor?gdImageGetTrueColorPixel:gdImageGetPixel) +#define MIN(a,b) ((a)<(b)?(a):(b)) +#define MAX(a,b) ((a)<(b)?(b):(a)) + +#ifdef _WIN32 +# define GD_SCATTER_SEED() (unsigned int)(time(0) * GetCurrentProcessId()) +#else +# define GD_SCATTER_SEED() (unsigned int)(time(0) * getpid()) +#endif + +BGD_DECLARE(int) gdImageScatter(gdImagePtr im, int sub, int plus) +{ + gdScatter s; + + s.sub = sub; + s.plus = plus; + s.num_colors = 0; + s.seed = GD_SCATTER_SEED(); + return gdImageScatterEx(im, &s); +} + +BGD_DECLARE(int) gdImageScatterColor(gdImagePtr im, int sub, int plus, int colors[], unsigned int num_colors) +{ + gdScatter s; + + s.sub = sub; + s.plus = plus; + s.colors = colors; + s.num_colors = num_colors; + s.seed = GD_SCATTER_SEED(); + return gdImageScatterEx(im, &s); +} + +BGD_DECLARE(int) gdImageScatterEx(gdImagePtr im, gdScatterPtr scatter) +{ + register int x, y; + int dest_x, dest_y; + int pxl, new_pxl; + unsigned int n; + int sub = scatter->sub, plus = scatter->plus; + + if (plus == 0 && sub == 0) { + return 1; + } else if (sub >= plus) { + return 0; + } + + (void)srand(scatter->seed); + + if (scatter->num_colors) { + for (y = 0; y < im->sy; y++) { + for (x = 0; x < im->sx; x++) { + dest_x = (int) (x + ((rand() % (plus - sub)) + sub)); + dest_y = (int) (y + ((rand() % (plus - sub)) + sub)); + + if (!gdImageBoundsSafe(im, dest_x, dest_y)) { + continue; + } + + pxl = gdImageGetPixel(im, x, y); + new_pxl = gdImageGetPixel(im, dest_x, dest_y); + + for (n = 0; n < scatter->num_colors; n++) { + if (pxl == scatter->colors[n]) { + gdImageSetPixel(im, dest_x, dest_y, pxl); + gdImageSetPixel(im, x, y, new_pxl); + } + } + } + } + } else { + for (y = 0; y < im->sy; y++) { + for (x = 0; x < im->sx; x++) { + dest_x = (int) (x + ((rand() % (plus - sub)) + sub)); + dest_y = (int) (y + ((rand() % (plus - sub)) + sub)); + + if (!gdImageBoundsSafe(im, dest_x, dest_y)) { + continue; + } + + pxl = gdImageGetPixel(im, x, y); + new_pxl = gdImageGetPixel(im, dest_x, dest_y); + + gdImageSetPixel(im, dest_x, dest_y, pxl); + gdImageSetPixel(im, x, y, new_pxl); + } + } + } + + return 1; +} + +BGD_DECLARE(int) gdImagePixelate(gdImagePtr im, int block_size, const unsigned int mode) +{ + int x, y; + + if (block_size <= 0) { + return 0; + } else if (block_size == 1) { + return 1; + } + switch (mode) { + case GD_PIXELATE_UPPERLEFT: + for (y = 0; y < im->sy; y += block_size) { + for (x = 0; x < im->sx; x += block_size) { + if (gdImageBoundsSafe(im, x, y)) { + int c = gdImageGetPixel(im, x, y); + gdImageFilledRectangle(im, x, y, x + block_size - 1, y + block_size - 1, c); + } + } + } + break; + case GD_PIXELATE_AVERAGE: + for (y = 0; y < im->sy; y += block_size) { + for (x = 0; x < im->sx; x += block_size) { + int a, r, g, b, c; + int total; + int cx, cy; + + a = r = g = b = c = total = 0; + /* sampling */ + for (cy = 0; cy < block_size; cy++) { + for (cx = 0; cx < block_size; cx++) { + if (!gdImageBoundsSafe(im, x + cx, y + cy)) { + continue; + } + c = gdImageGetPixel(im, x + cx, y + cy); + a += gdImageAlpha(im, c); + r += gdImageRed(im, c); + g += gdImageGreen(im, c); + b += gdImageBlue(im, c); + total++; + } + } + /* drawing */ + if (total > 0) { + c = gdImageColorResolveAlpha(im, r / total, g / total, b / total, a / total); + gdImageFilledRectangle(im, x, y, x + block_size - 1, y + block_size - 1, c); + } + } + } + break; + default: + return 0; + } + return 1; +} + +/* invert src image */ +BGD_DECLARE(int) gdImageNegate(gdImagePtr src) +{ + int x, y; + int r,g,b,a; + int new_pxl, pxl; + FuncPtr f; + + if (src==NULL) { + return 0; + } + + f = GET_PIXEL_FUNCTION(src); + + for (y=0; y<src->sy; ++y) { + for (x=0; x<src->sx; ++x) { + pxl = f (src, x, y); + r = gdImageRed(src, pxl); + g = gdImageGreen(src, pxl); + b = gdImageBlue(src, pxl); + a = gdImageAlpha(src, pxl); + + new_pxl = gdImageColorAllocateAlpha(src, 255-r, 255-g, 255-b, a); + if (new_pxl == -1) { + new_pxl = gdImageColorClosestAlpha(src, 255-r, 255-g, 255-b, a); + } + gdImageSetPixel (src, x, y, new_pxl); + } + } + return 1; +} + +/* Convert the image src to a grayscale image */ +BGD_DECLARE(int) gdImageGrayScale(gdImagePtr src) +{ + int x, y; + int r,g,b,a; + int new_pxl, pxl; + FuncPtr f; + + if (src==NULL) { + return 0; + } + + f = GET_PIXEL_FUNCTION(src); + + for (y=0; y<src->sy; ++y) { + for (x=0; x<src->sx; ++x) { + pxl = f (src, x, y); + r = gdImageRed(src, pxl); + g = gdImageGreen(src, pxl); + b = gdImageBlue(src, pxl); + a = gdImageAlpha(src, pxl); + r = g = b = (int) (.299 * r + .587 * g + .114 * b); + + new_pxl = gdImageColorAllocateAlpha(src, r, g, b, a); + if (new_pxl == -1) { + new_pxl = gdImageColorClosestAlpha(src, r, g, b, a); + } + gdImageSetPixel (src, x, y, new_pxl); + } + } + return 1; +} + +/* Set the brightness level <level> for the image src */ +BGD_DECLARE(int) gdImageBrightness(gdImagePtr src, int brightness) +{ + int x, y; + int r,g,b,a; + int new_pxl, pxl; + FuncPtr f; + + if (src==NULL || (brightness < -255 || brightness > 255)) { + return 0; + } + + if (brightness==0) { + return 1; + } + + f = GET_PIXEL_FUNCTION(src); + + for (y=0; y<src->sy; ++y) { + for (x=0; x<src->sx; ++x) { + pxl = f (src, x, y); + + r = gdImageRed(src, pxl); + g = gdImageGreen(src, pxl); + b = gdImageBlue(src, pxl); + a = gdImageAlpha(src, pxl); + + r = r + brightness; + g = g + brightness; + b = b + brightness; + + r = (r > 255)? 255 : ((r < 0)? 0:r); + g = (g > 255)? 255 : ((g < 0)? 0:g); + b = (b > 255)? 255 : ((b < 0)? 0:b); + + new_pxl = gdImageColorAllocateAlpha(src, (int)r, (int)g, (int)b, a); + if (new_pxl == -1) { + new_pxl = gdImageColorClosestAlpha(src, (int)r, (int)g, (int)b, a); + } + gdImageSetPixel (src, x, y, new_pxl); + } + } + return 1; +} + + +BGD_DECLARE(int) gdImageContrast(gdImagePtr src, double contrast) +{ + int x, y; + int r,g,b,a; + double rf,gf,bf; + int new_pxl, pxl; + + FuncPtr f; + + if (src==NULL) { + return 0; + } + + f = GET_PIXEL_FUNCTION(src); + + contrast = (double)(100.0-contrast)/100.0; + contrast = contrast*contrast; + + for (y=0; y<src->sy; ++y) { + for (x=0; x<src->sx; ++x) { + pxl = f(src, x, y); + + r = gdImageRed(src, pxl); + g = gdImageGreen(src, pxl); + b = gdImageBlue(src, pxl); + a = gdImageAlpha(src, pxl); + + rf = (double)r/255.0; + rf = rf-0.5; + rf = rf*contrast; + rf = rf+0.5; + rf = rf*255.0; + + bf = (double)b/255.0; + bf = bf-0.5; + bf = bf*contrast; + bf = bf+0.5; + bf = bf*255.0; + + gf = (double)g/255.0; + gf = gf-0.5; + gf = gf*contrast; + gf = gf+0.5; + gf = gf*255.0; + + rf = (rf > 255.0)? 255.0 : ((rf < 0.0)? 0.0:rf); + gf = (gf > 255.0)? 255.0 : ((gf < 0.0)? 0.0:gf); + bf = (bf > 255.0)? 255.0 : ((bf < 0.0)? 0.0:bf); + + new_pxl = gdImageColorAllocateAlpha(src, (int)rf, (int)gf, (int)bf, a); + if (new_pxl == -1) { + new_pxl = gdImageColorClosestAlpha(src, (int)rf, (int)gf, (int)bf, a); + } + gdImageSetPixel (src, x, y, new_pxl); + } + } + return 1; +} + + +BGD_DECLARE(int) gdImageColor(gdImagePtr src, const int red, const int green, const int blue, const int alpha) +{ + int x, y; + int new_pxl, pxl; + FuncPtr f; + + if (src == NULL) { + return 0; + } + + f = GET_PIXEL_FUNCTION(src); + + for (y=0; y<src->sy; ++y) { + for (x=0; x<src->sx; ++x) { + int r,g,b,a; + + pxl = f(src, x, y); + r = gdImageRed(src, pxl); + g = gdImageGreen(src, pxl); + b = gdImageBlue(src, pxl); + a = gdImageAlpha(src, pxl); + + r = r + red; + g = g + green; + b = b + blue; + a = a + alpha; + + r = (r > 255)? 255 : ((r < 0)? 0 : r); + g = (g > 255)? 255 : ((g < 0)? 0 : g); + b = (b > 255)? 255 : ((b < 0)? 0 : b); + a = (a > 127)? 127 : ((a < 0)? 0 : a); + + new_pxl = gdImageColorAllocateAlpha(src, r, g, b, a); + if (new_pxl == -1) { + new_pxl = gdImageColorClosestAlpha(src, r, g, b, a); + } + gdImageSetPixel (src, x, y, new_pxl); + } + } + return 1; +} + +BGD_DECLARE(int) gdImageConvolution(gdImagePtr src, float filter[3][3], float filter_div, float offset) +{ + int x, y, i, j, new_a; + float new_r, new_g, new_b; + int new_pxl, pxl=0; + gdImagePtr srcback; + FuncPtr f; + + if (src==NULL) { + return 0; + } + + /* We need the orinal image with each safe neoghb. pixel */ + srcback = gdImageCreateTrueColor (src->sx, src->sy); + if (srcback==NULL) { + return 0; + } + + gdImageSaveAlpha(srcback, 1); + new_pxl = gdImageColorAllocateAlpha(srcback, 0, 0, 0, 127); + gdImageFill(srcback, 0, 0, new_pxl); + + gdImageCopy(srcback, src,0,0,0,0,src->sx,src->sy); + + f = GET_PIXEL_FUNCTION(src); + + for ( y=0; y<src->sy; y++) { + for(x=0; x<src->sx; x++) { + new_r = new_g = new_b = 0; + new_a = gdImageAlpha(srcback, pxl); + + for (j=0; j<3; j++) { + int yv = MIN(MAX(y - 1 + j, 0), src->sy - 1); + for (i=0; i<3; i++) { + pxl = f(srcback, MIN(MAX(x - 1 + i, 0), src->sx - 1), yv); + new_r += (float)gdImageRed(srcback, pxl) * filter[j][i]; + new_g += (float)gdImageGreen(srcback, pxl) * filter[j][i]; + new_b += (float)gdImageBlue(srcback, pxl) * filter[j][i]; + } + } + + new_r = (new_r/filter_div)+offset; + new_g = (new_g/filter_div)+offset; + new_b = (new_b/filter_div)+offset; + + new_r = (new_r > 255.0f)? 255.0f : ((new_r < 0.0f)? 0.0f:new_r); + new_g = (new_g > 255.0f)? 255.0f : ((new_g < 0.0f)? 0.0f:new_g); + new_b = (new_b > 255.0f)? 255.0f : ((new_b < 0.0f)? 0.0f:new_b); + + new_pxl = gdImageColorAllocateAlpha(src, (int)new_r, (int)new_g, (int)new_b, new_a); + if (new_pxl == -1) { + new_pxl = gdImageColorClosestAlpha(src, (int)new_r, (int)new_g, (int)new_b, new_a); + } + gdImageSetPixel (src, x, y, new_pxl); + } + } + gdImageDestroy(srcback); + return 1; +} + +BGD_DECLARE(int) gdImageSelectiveBlur( gdImagePtr src) +{ + int x, y, i, j; + float new_r, new_g, new_b; + int new_pxl, cpxl, pxl, new_a=0; + float flt_r [3][3]; + float flt_g [3][3]; + float flt_b [3][3]; + float flt_r_sum, flt_g_sum, flt_b_sum; + + gdImagePtr srcback; + FuncPtr f; + + if (src==NULL) { + return 0; + } + + /* We need the orinal image with each safe neoghb. pixel */ + srcback = gdImageCreateTrueColor (src->sx, src->sy); + if (srcback==NULL) { + return 0; + } + gdImageCopy(srcback, src,0,0,0,0,src->sx,src->sy); + + f = GET_PIXEL_FUNCTION(src); + + for(y = 0; y<src->sy; y++) { + for (x=0; x<src->sx; x++) { + flt_r_sum = flt_g_sum = flt_b_sum = 0.0; + cpxl = f(src, x, y); + + for (j=0; j<3; j++) { + for (i=0; i<3; i++) { + if ((j == 1) && (i == 1)) { + flt_r[1][1] = flt_g[1][1] = flt_b[1][1] = 0.5; + } else { + pxl = f(src, x-(3>>1)+i, y-(3>>1)+j); + new_a = gdImageAlpha(srcback, pxl); + + new_r = ((float)gdImageRed(srcback, cpxl)) - ((float)gdImageRed (srcback, pxl)); + + if (new_r < 0.0f) { + new_r = -new_r; + } + if (new_r != 0) { + flt_r[j][i] = 1.0f/new_r; + } else { + flt_r[j][i] = 1.0f; + } + + new_g = ((float)gdImageGreen(srcback, cpxl)) - ((float)gdImageGreen(srcback, pxl)); + + if (new_g < 0.0f) { + new_g = -new_g; + } + if (new_g != 0) { + flt_g[j][i] = 1.0f/new_g; + } else { + flt_g[j][i] = 1.0f; + } + + new_b = ((float)gdImageBlue(srcback, cpxl)) - ((float)gdImageBlue(srcback, pxl)); + + if (new_b < 0.0f) { + new_b = -new_b; + } + if (new_b != 0) { + flt_b[j][i] = 1.0f/new_b; + } else { + flt_b[j][i] = 1.0f; + } + } + + flt_r_sum += flt_r[j][i]; + flt_g_sum += flt_g[j][i]; + flt_b_sum += flt_b [j][i]; + } + } + + for (j=0; j<3; j++) { + for (i=0; i<3; i++) { + if (flt_r_sum != 0.0) { + flt_r[j][i] /= flt_r_sum; + } + if (flt_g_sum != 0.0) { + flt_g[j][i] /= flt_g_sum; + } + if (flt_b_sum != 0.0) { + flt_b [j][i] /= flt_b_sum; + } + } + } + + new_r = new_g = new_b = 0.0; + + for (j=0; j<3; j++) { + for (i=0; i<3; i++) { + pxl = f(src, x-(3>>1)+i, y-(3>>1)+j); + new_r += (float)gdImageRed(srcback, pxl) * flt_r[j][i]; + new_g += (float)gdImageGreen(srcback, pxl) * flt_g[j][i]; + new_b += (float)gdImageBlue(srcback, pxl) * flt_b[j][i]; + } + } + + new_r = (new_r > 255.0f)? 255.0f : ((new_r < 0.0f)? 0.0f:new_r); + new_g = (new_g > 255.0f)? 255.0f : ((new_g < 0.0f)? 0.0f:new_g); + new_b = (new_b > 255.0f)? 255.0f : ((new_b < 0.0f)? 0.0f:new_b); + new_pxl = gdImageColorAllocateAlpha(src, (int)new_r, (int)new_g, (int)new_b, new_a); + if (new_pxl == -1) { + new_pxl = gdImageColorClosestAlpha(src, (int)new_r, (int)new_g, (int)new_b, new_a); + } + gdImageSetPixel (src, x, y, new_pxl); + } + } + gdImageDestroy(srcback); + return 1; +} + +BGD_DECLARE(int) gdImageEdgeDetectQuick(gdImagePtr src) +{ + float filter[3][3] = {{-1.0,0.0,-1.0}, + {0.0,4.0,0.0}, + {-1.0,0.0,-1.0}}; + + return gdImageConvolution(src, filter, 1, 127); +} + +/* + Function: gdImageGaussianBlur + + <gdImageGaussianBlur> performs a Gaussian blur of radius 1 on the + image. The image is modified in place. + + *NOTE:* You will almost certain want to use + <gdImageCopyGaussianBlurred> instead, as it allows you to change + your kernel size and sigma value. Future versions of this + function may fall back to calling it instead of + <gdImageConvolution>, causing subtle changes so be warned. + + Parameters: + im - The image to blur + + Returns: + GD_TRUE (1) on success, GD_FALSE (0) on failure. + +*/ + +BGD_DECLARE(int) gdImageGaussianBlur(gdImagePtr im) +{ + float filter[3][3] = { + {1.0, 2.0, 1.0}, + {2.0, 4.0, 2.0}, + {1.0, 2.0, 1.0} + }; + + return gdImageConvolution(im, filter, 16, 0); +} + +BGD_DECLARE(int) gdImageEmboss(gdImagePtr im) +{ +/* + float filter[3][3] = {{1.0,1.0,1.0}, + {0.0,0.0,0.0}, + {-1.0,-1.0,-1.0}}; +*/ + float filter[3][3] = {{ 1.5, 0.0, 0.0}, + { 0.0, 0.0, 0.0}, + { 0.0, 0.0,-1.5}}; + + return gdImageConvolution(im, filter, 1, 127); +} + +BGD_DECLARE(int) gdImageMeanRemoval(gdImagePtr im) +{ + float filter[3][3] = {{-1.0,-1.0,-1.0}, + {-1.0,9.0,-1.0}, + {-1.0,-1.0,-1.0}}; + + return gdImageConvolution(im, filter, 1, 0); +} + +BGD_DECLARE(int) gdImageSmooth(gdImagePtr im, float weight) +{ + float filter[3][3] = {{1.0,1.0,1.0}, + {1.0,0.0,1.0}, + {1.0,1.0,1.0}}; + + filter[1][1] = weight; + + return gdImageConvolution(im, filter, weight+8, 0); +} + + +/* ======================== Gaussian Blur Code ======================== */ + +/* Return an array of coefficients for 'radius' and 'sigma' (sigma >= + * 0 means compute it). Result length is 2*radius+1. */ +static double * +gaussian_coeffs(int radius, double sigmaArg) { + const double sigma = (sigmaArg <= 0.0) ? (2.0/3.0)*radius : sigmaArg; + const double s = 2.0 * sigma * sigma; + double *result; + double sum = 0; + int x, n, count; + + count = 2*radius + 1; + + result = gdMalloc(sizeof(double) * count); + if (!result) { + return NULL; + }/* if */ + + for (x = -radius; x <= radius; x++) { + double coeff = exp(-(x*x)/s); + + sum += coeff; + result[x + radius] = coeff; + }/* for */ + + for (n = 0; n < count; n++) { + result[n] /= sum; + }/* for */ + + return result; +}/* gaussian_coeffs*/ + + + +static inline int +reflect(int max, int x) +{ + assert(x > -max && x < 2*max); + + if(x < 0) return -x; + if(x >= max) return max - (x - max) - 1; + return x; +}/* reflect*/ + + + +static inline void +applyCoeffsLine(gdImagePtr src, gdImagePtr dst, int line, int linelen, + double *coeffs, int radius, gdAxis axis) +{ + int ndx; + + for (ndx = 0; ndx < linelen; ndx++) { + double r = 0, g = 0, b = 0, a = 0; + int cndx; + int *dest = (axis == HORIZONTAL) ? + &dst->tpixels[line][ndx] : + &dst->tpixels[ndx][line]; + + for (cndx = -radius; cndx <= radius; cndx++) { + const double coeff = coeffs[cndx + radius]; + const int rndx = reflect(linelen, ndx + cndx); + + const int srcpx = (axis == HORIZONTAL) ? + src->tpixels[line][rndx] : + src->tpixels[rndx][line]; + + r += coeff * (double)gdTrueColorGetRed(srcpx); + g += coeff * (double)gdTrueColorGetGreen(srcpx); + b += coeff * (double)gdTrueColorGetBlue(srcpx); + a += coeff * (double)gdTrueColorGetAlpha(srcpx); + }/* for */ + + *dest = gdTrueColorAlpha(uchar_clamp(r, 0xFF), uchar_clamp(g, 0xFF), + uchar_clamp(b, 0xFF), uchar_clamp(a, 0x7F)); + }/* for */ +}/* applyCoeffsLine*/ + + +static void +applyCoeffs(gdImagePtr src, gdImagePtr dst, double *coeffs, int radius, + gdAxis axis) +{ + int line, numlines, linelen; + + if (axis == HORIZONTAL) { + numlines = src->sy; + linelen = src->sx; + } else { + numlines = src->sx; + linelen = src->sy; + }/* if .. else*/ + + for (line = 0; line < numlines; line++) { + applyCoeffsLine(src, dst, line, linelen, coeffs, radius, axis); + }/* for */ +}/* applyCoeffs*/ + +/* + Function: gdImageCopyGaussianBlurred + + Return a copy of the source image _src_ blurred according to the + parameters using the Gaussian Blur algorithm. + + _radius_ is a radius, not a diameter so a radius of 2 (for + example) will blur across a region 5 pixels across (2 to the + center, 1 for the center itself and another 2 to the other edge). + + _sigma_ represents the "fatness" of the curve (lower == fatter). + If _sigma_ is less than or equal to 0, + <gdImageCopyGaussianBlurred> ignores it and instead computes an + "optimal" value. Be warned that future versions of this function + may compute sigma differently. + + The resulting image is always truecolor. + + More Details: + + A Gaussian Blur is generated by replacing each pixel's color + values with the average of the surrounding pixels' colors. This + region is a circle whose radius is given by argument _radius_. + Thus, a larger radius will yield a blurrier image. + + This average is not a simple mean of the values. Instead, values + are weighted using the Gaussian function (roughly a bell curve + centered around the destination pixel) giving it much more + influence on the result than its neighbours. Thus, a fatter curve + will give the center pixel more weight and make the image less + blurry; lower _sigma_ values will yield flatter curves. + + Currently, <gdImageCopyGaussianBlurred> computes the default sigma + as + + (2/3)*radius + + Note, however that we reserve the right to change this if we find + a better ratio. If you absolutely need the current sigma value, + you should set it yourself. + + Parameters: + + src - the source image + radius - the blur radius (*not* diameter--range is 2*radius + 1) + sigma - the sigma value or a value <= 0.0 to use the computed default + + Returns: + + The new image or NULL if an error occurred. The result is always + truecolor. + + Example: + + > FILE *in; + > gdImagePtr result, src; + > + > in = fopen("foo.png", "rb"); + > src = gdImageCreateFromPng(in); + > + > result = gdImageCopyGaussianBlurred(im, src->sx / 10, -1.0); + +*/ + +/* TODO: Look into turning this into a generic seperable filter + * function with Gaussian Blur being one special case. (At the + * moment, I can't find any other useful separable filter so for not, + * it's just blur.) */ +BGD_DECLARE(gdImagePtr) +gdImageCopyGaussianBlurred(gdImagePtr src, int radius, double sigma) +{ + gdImagePtr tmp = NULL, result = NULL; + double *coeffs; + int freeSrc = 0; + + if (radius < 1) { + return NULL; + }/* if */ + + /* Compute the coefficients. */ + coeffs = gaussian_coeffs(radius, sigma); + if (!coeffs) { + return NULL; + }/* if */ + + /* If the image is not truecolor, we first make a truecolor + * scratch copy. */ + if (!src->trueColor) { + int tcstat; + + src = gdImageClone(src); + if (!src) { + gdFree(coeffs); + return NULL; + } + + tcstat = gdImagePaletteToTrueColor(src); + if (!tcstat) { + gdImageDestroy(src); + gdFree(coeffs); + return NULL; + }/* if */ + + freeSrc = 1; + }/* if */ + + /* Apply the filter horizontally. */ + tmp = gdImageCreateTrueColor(src->sx, src->sy); + if (!tmp) { + gdFree(coeffs); + return NULL; + } + applyCoeffs(src, tmp, coeffs, radius, HORIZONTAL); + + /* Apply the filter vertically. */ + result = gdImageCreateTrueColor(src->sx, src->sy); + if (result) { + applyCoeffs(tmp, result, coeffs, radius, VERTICAL); + }/* if */ + + gdImageDestroy(tmp); + gdFree(coeffs); + + if (freeSrc) gdImageDestroy(src); + + return result; +}/* gdImageCopyGaussianBlurred*/ + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_gd.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_gd.c new file mode 100644 index 00000000000..f8d39cb00ce --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_gd.c @@ -0,0 +1,346 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include "gd.h" + +#define TRUE 1 +#define FALSE 0 + +/* Use this for commenting out debug-print statements. */ +/* Just use the first '#define' to allow all the prints... */ +/*#define GD2_DBG(s) (s) */ +#define GD2_DBG(s) + +/* */ +/* Shared code to read color tables from gd file. */ +/* */ +int +_gdGetColors (gdIOCtx * in, gdImagePtr im, int gd2xFlag) +{ + int i; + if (gd2xFlag) { + int trueColorFlag; + if (!gdGetByte (&trueColorFlag, in)) { + goto fail1; + } + /* 2.0.12: detect bad truecolor .gd files created by pre-2.0.12. + Beginning in 2.0.12 truecolor is indicated by the initial 2-byte + signature. */ + if (trueColorFlag != im->trueColor) { + goto fail1; + } + /* This should have been a word all along */ + if (!im->trueColor) { + if (!gdGetWord (&im->colorsTotal, in)) { + goto fail1; + } + if (im->colorsTotal > gdMaxColors) { + goto fail1; + } + } + /* Int to accommodate truecolor single-color transparency */ + if (!gdGetInt (&im->transparent, in)) { + goto fail1; + } + } else { + if (!gdGetByte (&im->colorsTotal, in)) { + goto fail1; + } + if (!gdGetWord (&im->transparent, in)) { + goto fail1; + } + if (im->transparent == 257) { + im->transparent = (-1); + } + } + GD2_DBG (printf + ("Palette had %d colours (T=%d)\n", im->colorsTotal, + im->transparent)); + if (im->trueColor) { + return TRUE; + } + for (i = 0; (i < gdMaxColors); i++) { + if (!gdGetByte (&im->red[i], in)) { + goto fail1; + } + if (!gdGetByte (&im->green[i], in)) { + goto fail1; + } + if (!gdGetByte (&im->blue[i], in)) { + goto fail1; + } + if (gd2xFlag) { + if (!gdGetByte (&im->alpha[i], in)) { + goto fail1; + } + } + } + + for (i = 0; (i < im->colorsTotal); i++) { + im->open[i] = 0; + }; + + return TRUE; +fail1: + return FALSE; +} + +/* */ +/* Use the common basic header info to make the image object. */ +/* */ +static gdImagePtr +_gdCreateFromFile (gdIOCtx * in, int *sx, int *sy) +{ + gdImagePtr im; + int gd2xFlag = 0; + int trueColorFlag = 0; + if (!gdGetWord (sx, in)) { + goto fail1; + } + if ((*sx == 65535) || (*sx == 65534)) { + /* This is a gd 2.0 .gd file */ + gd2xFlag = 1; + /* 2.0.12: 65534 signals a truecolor .gd file. + There is a slight redundancy here but we can + live with it. */ + if (*sx == 65534) { + trueColorFlag = 1; + } + if (!gdGetWord (sx, in)) { + goto fail1; + } + } + if (!gdGetWord (sy, in)) { + goto fail1; + } + + GD2_DBG (printf ("Image is %dx%d\n", *sx, *sy)); + if (trueColorFlag) { + im = gdImageCreateTrueColor (*sx, *sy); + } else { + im = gdImageCreate (*sx, *sy); + } + if (!im) { + goto fail1; + } + if (!_gdGetColors (in, im, gd2xFlag)) { + goto fail2; + } + + return im; +fail2: + gdImageDestroy (im); +fail1: + return 0; +} + +/* + Function: gdImageCreateFromGd + + <gdImageCreateFromGd> is called to load images from gd format + files. Invoke <gdImageCreateFromGd> with an already opened pointer + to a file containing the desired image in the gd file format, + which is specific to gd and intended for very fast loading. (It is + not intended for compression; for compression, use PNG or JPEG.) + + <gdImageCreateFromGd> returns a <gdImagePtr> to the new image, or + NULL if unable to load the image (most often because the file is + corrupt or does not contain a gd format + image). <gdImageCreateFromGd> does not close the file. You can + inspect the sx and sy members of the image to determine its + size. The image must eventually be destroyed using + <gdImageDestroy>. + + Variants: + + <gdImageCreateFromGdPtr> creates an image from GD data (i.e. the + contents of a GD file) already in memory. + + <gdImageCreateFromGdCtx> reads in an image using the functions in + a <gdIOCtx> struct. + + Parameters: + + infile - The input FILE pointer + + Returns: + + A pointer to the new image or NULL if an error occurred. + + Example: + + > gdImagePtr im; + > FILE *in; + > in = fopen("mygd.gd", "rb"); + > im = gdImageCreateFromGd(in); + > fclose(in); + > // ... Use the image ... + > gdImageDestroy(im); +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd (FILE * inFile) +{ + gdImagePtr im; + gdIOCtx *in; + + in = gdNewFileCtx (inFile); + if (in == NULL) return NULL; + im = gdImageCreateFromGdCtx (in); + + in->gd_free (in); + + return im; +} + +/* + Function: gdImageCreateFromGdPtr + + Parameters: + + size - size of GD data in bytes. + data - GD data (i.e. contents of a GIF file). + + Reads in GD data from memory. See <gdImageCreateFromGd>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGdPtr (int size, void *data) +{ + gdImagePtr im; + gdIOCtx *in = gdNewDynamicCtxEx (size, data, 0); + if(!in) + return 0; + im = gdImageCreateFromGdCtx (in); + in->gd_free (in); + return im; +} + +/* + Function: gdImageCreateFromGdCtx + + Reads in a GD image via a <gdIOCtx> struct. See + <gdImageCreateFromGd>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGdCtx (gdIOCtxPtr in) +{ + int sx, sy; + int x, y; + gdImagePtr im; + + /* Read the header */ + im = _gdCreateFromFile (in, &sx, &sy); + + if (im == NULL) { + goto fail1; + }; + + /* Then the data... */ + /* 2.0.12: support truecolor properly in .gd as well as in .gd2. + Problem reported by Andreas Pfaller. */ + if (im->trueColor) { + for (y = 0; (y < sy); y++) { + for (x = 0; (x < sx); x++) { + int pix; + if (!gdGetInt (&pix, in)) { + goto fail2; + } + im->tpixels[y][x] = pix; + } + } + } else { + for (y = 0; (y < sy); y++) { + for (x = 0; (x < sx); x++) { + int ch; + ch = gdGetC (in); + if (ch == EOF) { + goto fail2; + } + /* ROW-MAJOR IN GD 1.3 */ + im->pixels[y][x] = ch; + } + } + } + return im; + +fail2: + gdImageDestroy (im); +fail1: + return 0; +} + +void +_gdPutColors (gdImagePtr im, gdIOCtx * out) +{ + int i; + + gdPutC (im->trueColor, out); + if (!im->trueColor) { + gdPutWord (im->colorsTotal, out); + } + gdPutInt (im->transparent, out); + if (!im->trueColor) { + for (i = 0; (i < gdMaxColors); i++) { + gdPutC ((unsigned char) im->red[i], out); + gdPutC ((unsigned char) im->green[i], out); + gdPutC ((unsigned char) im->blue[i], out); + gdPutC ((unsigned char) im->alpha[i], out); + } + } +} + +static void +_gdPutHeader (gdImagePtr im, gdIOCtx * out) +{ + /* 65535 indicates this is a gd 2.x .gd file. + 2.0.12: 65534 indicates truecolor. */ + if (im->trueColor) { + gdPutWord (65534, out); + } else { + gdPutWord (65535, out); + } + gdPutWord (im->sx, out); + gdPutWord (im->sy, out); + + _gdPutColors (im, out); + +} + +static void +_gdImageGd (gdImagePtr im, gdIOCtx * out) +{ + int x, y; + + _gdPutHeader (im, out); + + for (y = 0; (y < im->sy); y++) { + for (x = 0; (x < im->sx); x++) { + /* ROW-MAJOR IN GD 1.3 */ + if (im->trueColor) { + gdPutInt (im->tpixels[y][x], out); + } else { + gdPutC ((unsigned char) im->pixels[y][x], out); + } + } + } +} + +BGD_DECLARE(void) gdImageGd (gdImagePtr im, FILE * outFile) +{ + gdIOCtx *out = gdNewFileCtx (outFile); + if (out == NULL) return; + _gdImageGd (im, out); + out->gd_free (out); +} + +BGD_DECLARE(void *) gdImageGdPtr (gdImagePtr im, int *size) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx (2048, NULL); + if (out == NULL) return NULL; + _gdImageGd (im, out); + rv = gdDPExtractData (out, size); + out->gd_free (out); + return rv; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_gd2.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_gd2.c new file mode 100644 index 00000000000..3e70bfac673 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_gd2.c @@ -0,0 +1,1070 @@ +/* + * gd_gd2.c + * + * Implements the I/O and support for the GD2 format. + * + * Changing the definition of GD2_DBG (below) will cause copious messages + * to be displayed while it processes requests. + * + * Designed, Written & Copyright 1999, Philip Warner. + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +/* 2.0.29: no more errno.h, makes windows happy */ +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include "gd.h" +#include "gd_errors.h" +#include "gdhelpers.h" + +/* 2.03: gd2 is no longer mandatory */ +/* JCE - test after including gd.h so that HAVE_LIBZ can be set in + * a config.h file included by gd.h */ +#ifdef HAVE_LIBZ +#include <zlib.h> + +#define TRUE 1 +#define FALSE 0 + +/* 2.11: not part of the API, as the save routine can figure it out + from im->trueColor, and the load routine doesn't need to tell + the end user the saved format. NOTE: adding 2 is assumed + to result in the correct format value for truecolor! */ +#define GD2_FMT_TRUECOLOR_RAW 3 +#define GD2_FMT_TRUECOLOR_COMPRESSED 4 + +#define gd2_compressed(fmt) (((fmt) == GD2_FMT_COMPRESSED) || \ + ((fmt) == GD2_FMT_TRUECOLOR_COMPRESSED)) + +#define gd2_truecolor(fmt) (((fmt) == GD2_FMT_TRUECOLOR_RAW) || \ + ((fmt) == GD2_FMT_TRUECOLOR_COMPRESSED)) + +/* Use this for commenting out debug-print statements. */ +/* Just use the first '#define' to allow all the prints... */ +/*#define GD2_DBG(s) (s) */ +#define GD2_DBG(s) + +typedef struct { + int offset; + int size; +} +t_chunk_info; + +extern int _gdGetColors (gdIOCtx * in, gdImagePtr im, int gd2xFlag); +extern void _gdPutColors (gdImagePtr im, gdIOCtx * out); + +/* */ +/* Read the extra info in the gd2 header. */ +/* */ +static int +_gd2GetHeader (gdIOCtxPtr in, int *sx, int *sy, + int *cs, int *vers, int *fmt, int *ncx, int *ncy, + t_chunk_info ** chunkIdx) +{ + int i; + int ch; + char id[5]; + t_chunk_info *cidx; + int sidx; + int nc; + + GD2_DBG (printf ("Reading gd2 header info\n")); + + for (i = 0; i < 4; i++) { + ch = gdGetC (in); + if (ch == EOF) { + goto fail1; + }; + id[i] = ch; + }; + id[4] = 0; + + GD2_DBG (printf ("Got file code: %s\n", id)); + + /* Equiv. of 'magick'. */ + if (strcmp (id, GD2_ID) != 0) { + GD2_DBG (printf ("Not a valid gd2 file\n")); + goto fail1; + }; + + /* Version */ + if (gdGetWord (vers, in) != 1) { + goto fail1; + }; + GD2_DBG (printf ("Version: %d\n", *vers)); + + if ((*vers != 1) && (*vers != 2)) { + GD2_DBG (printf ("Bad version: %d\n", *vers)); + goto fail1; + }; + + /* Image Size */ + if (!gdGetWord (sx, in)) { + GD2_DBG (printf ("Could not get x-size\n")); + goto fail1; + } + if (!gdGetWord (sy, in)) { + GD2_DBG (printf ("Could not get y-size\n")); + goto fail1; + } + GD2_DBG (printf ("Image is %dx%d\n", *sx, *sy)); + + /* Chunk Size (pixels, not bytes!) */ + if (gdGetWord (cs, in) != 1) { + goto fail1; + }; + GD2_DBG (printf ("ChunkSize: %d\n", *cs)); + + if ((*cs < GD2_CHUNKSIZE_MIN) || (*cs > GD2_CHUNKSIZE_MAX)) { + GD2_DBG (printf ("Bad chunk size: %d\n", *cs)); + goto fail1; + }; + + /* Data Format */ + if (gdGetWord (fmt, in) != 1) { + goto fail1; + }; + GD2_DBG (printf ("Format: %d\n", *fmt)); + + if ((*fmt != GD2_FMT_RAW) && (*fmt != GD2_FMT_COMPRESSED) && + (*fmt != GD2_FMT_TRUECOLOR_RAW) && + (*fmt != GD2_FMT_TRUECOLOR_COMPRESSED)) { + GD2_DBG (printf ("Bad data format: %d\n", *fmt)); + goto fail1; + }; + + + /* # of chunks wide */ + if (gdGetWord (ncx, in) != 1) { + goto fail1; + }; + GD2_DBG (printf ("%d Chunks Wide\n", *ncx)); + + /* # of chunks high */ + if (gdGetWord (ncy, in) != 1) { + goto fail1; + }; + GD2_DBG (printf ("%d Chunks vertically\n", *ncy)); + + if (gd2_compressed (*fmt)) { + nc = (*ncx) * (*ncy); + GD2_DBG (printf ("Reading %d chunk index entries\n", nc)); + sidx = sizeof (t_chunk_info) * nc; + cidx = gdCalloc (sidx, 1); + if (!cidx) { + goto fail1; + } + for (i = 0; i < nc; i++) { + if (gdGetInt (&cidx[i].offset, in) != 1) { + goto fail2; + }; + if (gdGetInt (&cidx[i].size, in) != 1) { + goto fail2; + }; + }; + *chunkIdx = cidx; + }; + + GD2_DBG (printf ("gd2 header complete\n")); + + return 1; +fail2: + gdFree(cidx); +fail1: + return 0; +} + +static gdImagePtr +_gd2CreateFromFile (gdIOCtxPtr in, int *sx, int *sy, + int *cs, int *vers, int *fmt, + int *ncx, int *ncy, t_chunk_info ** cidx) +{ + gdImagePtr im; + + if (_gd2GetHeader (in, sx, sy, cs, vers, fmt, ncx, ncy, cidx) != 1) { + GD2_DBG (printf ("Bad GD2 header\n")); + goto fail1; + } + if (gd2_truecolor (*fmt)) { + im = gdImageCreateTrueColor (*sx, *sy); + } else { + im = gdImageCreate (*sx, *sy); + } + if (im == NULL) { + GD2_DBG (printf ("Could not create gdImage\n")); + goto fail2; + }; + + if (!_gdGetColors (in, im, (*vers) == 2)) { + GD2_DBG (printf ("Could not read color palette\n")); + goto fail3; + } + GD2_DBG (printf ("Image palette completed: %d colours\n", im->colorsTotal)); + + return im; + +fail3: + gdImageDestroy (im); +fail2: + gdFree(*cidx); +fail1: + return 0; + +} + +static int +_gd2ReadChunk (int offset, char *compBuf, int compSize, char *chunkBuf, + uLongf * chunkLen, gdIOCtx * in) +{ + int zerr; + + if (gdTell (in) != offset) { + GD2_DBG (printf ("Positioning in file to %d\n", offset)); + gdSeek (in, offset); + } else { + GD2_DBG (printf ("Already Positioned in file to %d\n", offset)); + }; + + /* Read and uncompress an entire chunk. */ + GD2_DBG (printf ("Reading file\n")); + if (gdGetBuf (compBuf, compSize, in) != compSize) { + return FALSE; + }; + GD2_DBG (printf + ("Got %d bytes. Uncompressing into buffer of %d bytes\n", compSize, + *chunkLen)); + zerr = + uncompress ((unsigned char *) chunkBuf, chunkLen, + (unsigned char *) compBuf, compSize); + if (zerr != Z_OK) { + GD2_DBG (printf ("Error %d from uncompress\n", zerr)); + return FALSE; + }; + GD2_DBG (printf ("Got chunk\n")); + return TRUE; +} + + +/* + Function: gdImageCreateFromGd2 + + <gdImageCreateFromGd2> is called to load images from gd2 format + files. Invoke <gdImageCreateFromGd2> with an already opened + pointer to a file containing the desired image in the gd2 file + format, which is specific to gd2 and intended for fast loading of + parts of large images. (It is a compressed format, but generally + not as good as maximum compression of the entire image would be.) + + <gdImageCreateFromGd2> returns a <gdImagePtr> to the new image, or + NULL if unable to load the image (most often because the file is + corrupt or does not contain a gd format + image). <gdImageCreateFromGd2> does not close the file. You can + inspect the sx and sy members of the image to determine its + size. The image must eventually be destroyed using + <gdImageDestroy>. + + + Variants: + + <gdImageCreateFromGd2Ptr> creates an image from GD data (i.e. the + contents of a GD2 file) already in memory. + + <gdImageCreateFromGd2Ctx> reads in an image using the functions in + a <gdIOCtx> struct. + + Parameters: + + infile - The input FILE pointer + + Returns: + + A pointer to the new image or NULL if an error occurred. + + Example: + + > gdImagePtr im; + > FILE *in; + > in = fopen("mygd.gd2", "rb"); + > im = gdImageCreateFromGd2(in); + > fclose(in); + > // ... Use the image ... + > gdImageDestroy(im); +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2 (FILE * inFile) +{ + gdIOCtx *in = gdNewFileCtx (inFile); + gdImagePtr im; + + if (in == NULL) return NULL; + im = gdImageCreateFromGd2Ctx (in); + + in->gd_free (in); + + return im; +} + +/* + Function: gdImageCreateFromGd2Ptr + + Parameters: + + size - size of GD2 data in bytes. + data - GD2 data (i.e. contents of a GIF file). + + See <gdImageCreateFromGd2>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Ptr (int size, void *data) +{ + gdImagePtr im; + gdIOCtx *in = gdNewDynamicCtxEx (size, data, 0); + if(!in) + return 0; + im = gdImageCreateFromGd2Ctx (in); + in->gd_free (in); + return im; +} + +/* + Function: gdImageCreateFromGd2Ctx + + Reads in a GD2 image via a <gdIOCtx> struct. See + <gdImageCreateFromGd2>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Ctx (gdIOCtxPtr in) +{ + int sx, sy; + int i; + int ncx, ncy, nc, cs, cx, cy; + int x, y, ylo, yhi, xlo, xhi; + int vers, fmt; + t_chunk_info *chunkIdx = NULL; /* So we can gdFree it with impunity. */ + unsigned char *chunkBuf = NULL; /* So we can gdFree it with impunity. */ + int chunkNum = 0; + int chunkMax = 0; + uLongf chunkLen; + int chunkPos = 0; + int compMax = 0; + int bytesPerPixel; + char *compBuf = NULL; /* So we can gdFree it with impunity. */ + + gdImagePtr im; + + /* Get the header */ + im = + _gd2CreateFromFile (in, &sx, &sy, &cs, &vers, &fmt, &ncx, &ncy, + &chunkIdx); + + if (im == NULL) { + gdFree (chunkIdx); + return 0; + } + + bytesPerPixel = im->trueColor ? 4 : 1; + nc = ncx * ncy; + + if (gd2_compressed (fmt)) { + /* Find the maximum compressed chunk size. */ + compMax = 0; + for (i = 0; (i < nc); i++) { + if (chunkIdx[i].size > compMax) { + compMax = chunkIdx[i].size; + }; + }; + compMax++; + + /* Allocate buffers */ + chunkMax = cs * bytesPerPixel * cs; + chunkBuf = gdCalloc (chunkMax, 1); + if (!chunkBuf) { + goto fail; + } + compBuf = gdCalloc (compMax, 1); + if (!compBuf) { + goto fail; + } + + GD2_DBG (printf ("Largest compressed chunk is %d bytes\n", compMax)); + }; + + /* if ( (ncx != sx / cs) || (ncy != sy / cs)) { */ + /* goto fail2; */ + /* }; */ + + /* Read the data... */ + for (cy = 0; (cy < ncy); cy++) { + for (cx = 0; (cx < ncx); cx++) { + + ylo = cy * cs; + yhi = ylo + cs; + if (yhi > im->sy) { + yhi = im->sy; + }; + + GD2_DBG (printf + ("Processing Chunk %d (%d, %d), y from %d to %d\n", + chunkNum, cx, cy, ylo, yhi)); + + if (gd2_compressed (fmt)) { + + chunkLen = chunkMax; + + if (!_gd2ReadChunk (chunkIdx[chunkNum].offset, + compBuf, + chunkIdx[chunkNum].size, + (char *) chunkBuf, &chunkLen, in)) { + GD2_DBG (printf ("Error reading comproessed chunk\n")); + goto fail; + }; + + chunkPos = 0; + }; + + for (y = ylo; (y < yhi); y++) { + + xlo = cx * cs; + xhi = xlo + cs; + if (xhi > im->sx) { + xhi = im->sx; + }; + /*GD2_DBG(printf("y=%d: ",y)); */ + if (!gd2_compressed (fmt)) { + for (x = xlo; x < xhi; x++) { + + if (im->trueColor) { + if (!gdGetInt (&im->tpixels[y][x], in)) { + /*printf("EOF while reading\n"); */ + /*gdImageDestroy(im); */ + /*return 0; */ + im->tpixels[y][x] = 0; + } + } else { + int ch; + if (!gdGetByte (&ch, in)) { + /*printf("EOF while reading\n"); */ + /*gdImageDestroy(im); */ + /*return 0; */ + ch = 0; + } + im->pixels[y][x] = ch; + } + } + } else { + for (x = xlo; x < xhi; x++) { + if (im->trueColor) { + /* 2.0.1: work around a gcc bug by being verbose. + TBB */ + int a = chunkBuf[chunkPos++] << 24; + int r = chunkBuf[chunkPos++] << 16; + int g = chunkBuf[chunkPos++] << 8; + int b = chunkBuf[chunkPos++]; + /* 2.0.11: tpixels */ + im->tpixels[y][x] = a + r + g + b; + } else { + im->pixels[y][x] = chunkBuf[chunkPos++]; + } + }; + }; + /*GD2_DBG(printf("\n")); */ + }; + chunkNum++; + }; + }; + + GD2_DBG (printf ("Freeing memory\n")); + + gdFree (chunkBuf); + gdFree (compBuf); + gdFree (chunkIdx); + + GD2_DBG (printf ("Done\n")); + + return im; + +fail: + gdImageDestroy (im); + if (chunkBuf) { + gdFree (chunkBuf); + } + if (compBuf) { + gdFree (compBuf); + } + if (chunkIdx) { + gdFree (chunkIdx); + } + return 0; +} + + +/* + Function: gdImageCreateFromGd2Part + + <gdImageCreateFromGd2Part> is called to load parts of images from + gd2 format files. Invoked in the same way as <gdImageCreateFromGd2>, + but with extra parameters indicating the source (x, y) and + width/height of the desired image. <gdImageCreateFromGd2Part> + returns a <gdImagePtr> to the new image, or NULL if unable to load + the image. The image must eventually be destroyed using + <gdImageDestroy>. + + Variants: + + <gdImageCreateFromGd2PartPtr> creates an image from GD2 data + (i.e. the contents of a GD2 file) already in memory. + + <gdImageCreateFromGd2Ctx> reads in an image using the functions in + a <gdIOCtx> struct. + + Parameters: + + infile - The input FILE pointer + srcx, srcy - The source X and Y coordinates + w, h - The resulting image's width and height + + Returns: + + A pointer to the new image or NULL if an error occurred. + +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Part (FILE * inFile, int srcx, int srcy, int w, int h) +{ + gdImagePtr im; + gdIOCtx *in = gdNewFileCtx (inFile); + + if (in == NULL) return NULL; + im = gdImageCreateFromGd2PartCtx (in, srcx, srcy, w, h); + + in->gd_free (in); + + return im; +} + +/* + Function: gdImageCreateFromGd2PartPtr + + Parameters: + + size - size of GD data in bytes. + data - GD data (i.e. contents of a GIF file). + srcx, srcy - The source X and Y coordinates + w, h - The resulting image's width and height + + Reads in part of a GD2 image file stored from memory. See + <gdImageCreateFromGd2Part>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2PartPtr (int size, void *data, int srcx, int srcy, int w, + int h) +{ + gdImagePtr im; + gdIOCtx *in = gdNewDynamicCtxEx (size, data, 0); + if(!in) + return 0; + im = gdImageCreateFromGd2PartCtx (in, srcx, srcy, w, h); + in->gd_free (in); + return im; +} + + +/* + Function: gdImageCreateFromGd2PartCtx + + Parameters: + + in - The data source. + srcx, srcy - The source X and Y coordinates + w, h - The resulting image's width and height + + Reads in part of a GD2 data image file via a <gdIOCtx> struct. See + <gdImageCreateFromGd2Part>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2PartCtx (gdIOCtx * in, int srcx, int srcy, int w, int h) +{ + int scx, scy, ecx, ecy, fsx, fsy; + int nc, ncx, ncy, cs, cx, cy; + int x, y, ylo, yhi, xlo, xhi; + int dstart, dpos; + int i; + /* 2.0.12: unsigned is correct; fixes problems with color munging. + Thanks to Steven Brown. */ + unsigned int ch; + int vers, fmt; + t_chunk_info *chunkIdx = NULL; + unsigned char *chunkBuf = NULL; + int chunkNum; + int chunkMax = 0; + uLongf chunkLen; + int chunkPos = 0; + int compMax; + char *compBuf = NULL; + + gdImagePtr im; + + /* */ + /* The next few lines are basically copied from gd2CreateFromFile */ + /* - we change the file size, so don't want to use the code directly. */ + /* but we do need to know the file size. */ + /* */ + if (_gd2GetHeader (in, &fsx, &fsy, &cs, &vers, &fmt, &ncx, &ncy, &chunkIdx) + != 1) { + goto fail1; + } + + GD2_DBG (printf ("File size is %dx%d\n", fsx, fsy)); + + /* This is the difference - make a file based on size of chunks. */ + if (gd2_truecolor (fmt)) { + im = gdImageCreateTrueColor (w, h); + } else { + im = gdImageCreate (w, h); + } + if (im == NULL) { + goto fail1; + }; + + if (!_gdGetColors (in, im, vers == 2)) { + goto fail2; + } + GD2_DBG (printf ("Image palette completed: %d colours\n", im->colorsTotal)); + + /* Process the header info */ + nc = ncx * ncy; + + if (gd2_compressed (fmt)) { + /* Find the maximum compressed chunk size. */ + compMax = 0; + for (i = 0; (i < nc); i++) { + if (chunkIdx[i].size > compMax) { + compMax = chunkIdx[i].size; + }; + }; + compMax++; + + if (im->trueColor) { + chunkMax = cs * cs * 4; + } else { + chunkMax = cs * cs; + } + chunkBuf = gdCalloc (chunkMax, 1); + if (!chunkBuf) { + goto fail2; + } + compBuf = gdCalloc (compMax, 1); + if (!compBuf) { + goto fail2; + } + + }; + + /* Don't bother with this... */ + /* if ( (ncx != sx / cs) || (ncy != sy / cs)) { */ + /* goto fail2; */ + /* }; */ + + + /* Work out start/end chunks */ + scx = srcx / cs; + scy = srcy / cs; + if (scx < 0) { + scx = 0; + }; + if (scy < 0) { + scy = 0; + }; + + ecx = (srcx + w) / cs; + ecy = (srcy + h) / cs; + if (ecx >= ncx) { + ecx = ncx - 1; + }; + if (ecy >= ncy) { + ecy = ncy - 1; + }; + + /* Remember file position of image data. */ + dstart = gdTell (in); + GD2_DBG (printf ("Data starts at %d\n", dstart)); + + /* Loop through the chunks. */ + for (cy = scy; (cy <= ecy); cy++) { + + ylo = cy * cs; + yhi = ylo + cs; + if (yhi > fsy) { + yhi = fsy; + }; + + for (cx = scx; (cx <= ecx); cx++) { + + xlo = cx * cs; + xhi = xlo + cs; + if (xhi > fsx) { + xhi = fsx; + }; + + GD2_DBG (printf + ("Processing Chunk (%d, %d), from %d to %d\n", cx, cy, ylo, + yhi)); + + if (!gd2_compressed (fmt)) { + GD2_DBG (printf ("Using raw format data\n")); + if (im->trueColor) { + dpos = + (cy * (cs * fsx) * 4 + cx * cs * (yhi - ylo) * 4) + + dstart; + } else { + dpos = cy * (cs * fsx) + cx * cs * (yhi - ylo) + dstart; + } + /* gd 2.0.11: gdSeek returns TRUE on success, not 0. + Longstanding bug. 01/16/03 */ + if (!gdSeek (in, dpos)) { + gd_error("Seek error\n"); + goto fail2; + }; + GD2_DBG (printf + ("Reading (%d, %d) from position %d\n", cx, cy, + dpos - dstart)); + } else { + chunkNum = cx + cy * ncx; + + chunkLen = chunkMax; + if (!_gd2ReadChunk (chunkIdx[chunkNum].offset, + compBuf, + chunkIdx[chunkNum].size, + (char *) chunkBuf, &chunkLen, in)) { + printf ("Error reading comproessed chunk\n"); + goto fail2; + }; + chunkPos = 0; + GD2_DBG (printf + ("Reading (%d, %d) from chunk %d\n", cx, cy, + chunkNum)); + }; + + GD2_DBG (printf + (" into (%d, %d) - (%d, %d)\n", xlo, ylo, xhi, yhi)); + for (y = ylo; (y < yhi); y++) { + + for (x = xlo; x < xhi; x++) { + if (!gd2_compressed (fmt)) { + if (im->trueColor) { + if (!gdGetInt ((int *) &ch, in)) { + ch = 0; + /*printf("EOF while reading file\n"); */ + /*goto fail2; */ + } + } else { + ch = gdGetC (in); + if ((int) ch == EOF) { + ch = 0; + /*printf("EOF while reading file\n"); */ + /*goto fail2; */ + } + } + } else { + if (im->trueColor) { + ch = chunkBuf[chunkPos++]; + ch = (ch << 8) + chunkBuf[chunkPos++]; + ch = (ch << 8) + chunkBuf[chunkPos++]; + ch = (ch << 8) + chunkBuf[chunkPos++]; + } else { + ch = chunkBuf[chunkPos++]; + } + }; + + /* Only use a point that is in the image. */ + if ((x >= srcx) && (x < (srcx + w)) && (x < fsx) && (x >= 0) + && (y >= srcy) && (y < (srcy + h)) && (y < fsy) + && (y >= 0)) { + /* 2.0.11: tpixels */ + if (im->trueColor) { + im->tpixels[y - srcy][x - srcx] = ch; + } else { + im->pixels[y - srcy][x - srcx] = ch; + } + } + }; + }; + }; + }; + + gdFree (chunkBuf); + gdFree (compBuf); + gdFree (chunkIdx); + + return im; + +fail2: + gdImageDestroy (im); +fail1: + if (chunkBuf) { + gdFree (chunkBuf); + } + if (compBuf) { + gdFree (compBuf); + } + if (chunkIdx) { + gdFree (chunkIdx); + } + return 0; + +} + +static void +_gd2PutHeader (gdImagePtr im, gdIOCtx * out, int cs, int fmt, int cx, int cy) +{ + int i; + + /* Send the gd2 id, to verify file format. */ + for (i = 0; i < 4; i++) { + gdPutC ((unsigned char) (GD2_ID[i]), out); + }; + + /* */ + /* We put the version info first, so future versions can easily change header info. */ + /* */ + gdPutWord (GD2_VERS, out); + gdPutWord (im->sx, out); + gdPutWord (im->sy, out); + gdPutWord (cs, out); + gdPutWord (fmt, out); + gdPutWord (cx, out); + gdPutWord (cy, out); + +} + +static void +_gdImageGd2 (gdImagePtr im, gdIOCtx * out, int cs, int fmt) +{ + int ncx, ncy, cx, cy; + int x, y, ylo, yhi, xlo, xhi; + int chunkLen; + int chunkNum = 0; + char *chunkData = NULL; /* So we can gdFree it with impunity. */ + char *compData = NULL; /* So we can gdFree it with impunity. */ + uLongf compLen; + int idxPos = 0; + int idxSize; + t_chunk_info *chunkIdx = NULL; + int posSave; + int bytesPerPixel = im->trueColor ? 4 : 1; + int compMax = 0; + + /*printf("Trying to write GD2 file\n"); */ + + /* */ + /* Force fmt to a valid value since we don't return anything. */ + /* */ + if ((fmt != GD2_FMT_RAW) && (fmt != GD2_FMT_COMPRESSED)) { + fmt = im->trueColor ? GD2_FMT_TRUECOLOR_COMPRESSED : GD2_FMT_COMPRESSED; + }; + if (im->trueColor) { + fmt += 2; + } + /* */ + /* Make sure chunk size is valid. These are arbitrary values; 64 because it seems */ + /* a little silly to expect performance improvements on a 64x64 bit scale, and */ + /* 4096 because we buffer one chunk, and a 16MB buffer seems a little large - it may be */ + /* OK for one user, but for another to read it, they require the buffer. */ + /* */ + if (cs == 0) { + cs = GD2_CHUNKSIZE; + } else if (cs < GD2_CHUNKSIZE_MIN) { + cs = GD2_CHUNKSIZE_MIN; + } else if (cs > GD2_CHUNKSIZE_MAX) { + cs = GD2_CHUNKSIZE_MAX; + }; + + /* Work out number of chunks. */ + ncx = im->sx / cs + 1; + ncy = im->sy / cs + 1; + + /* Write the standard header. */ + _gd2PutHeader (im, out, cs, fmt, ncx, ncy); + + if (gd2_compressed (fmt)) { + /* */ + /* Work out size of buffer for compressed data, If CHUNKSIZE is large, */ + /* then these will be large! */ + /* */ + /* The zlib notes say output buffer size should be (input size) * 1.01 * 12 */ + /* - we'll use 1.02 to be paranoid. */ + /* */ + compMax = cs * bytesPerPixel * cs * 1.02 + 12; + + /* */ + /* Allocate the buffers. */ + /* */ + chunkData = gdCalloc (cs * bytesPerPixel * cs, 1); + if (!chunkData) { + goto fail; + } + compData = gdCalloc (compMax, 1); + if (!compData) { + goto fail; + } + + /* */ + /* Save the file position of chunk index, and allocate enough space for */ + /* each chunk_info block . */ + /* */ + idxPos = gdTell (out); + idxSize = ncx * ncy * sizeof (t_chunk_info); + GD2_DBG (printf ("Index size is %d\n", idxSize)); + gdSeek (out, idxPos + idxSize); + + chunkIdx = gdCalloc (idxSize * sizeof (t_chunk_info), 1); + if (!chunkIdx) { + goto fail; + } + }; + + _gdPutColors (im, out); + + GD2_DBG (printf ("Size: %dx%d\n", im->sx, im->sy)); + GD2_DBG (printf ("Chunks: %dx%d\n", ncx, ncy)); + + for (cy = 0; (cy < ncy); cy++) { + for (cx = 0; (cx < ncx); cx++) { + + ylo = cy * cs; + yhi = ylo + cs; + if (yhi > im->sy) { + yhi = im->sy; + }; + + GD2_DBG (printf + ("Processing Chunk (%dx%d), y from %d to %d\n", cx, cy, + ylo, yhi)); + chunkLen = 0; + for (y = ylo; (y < yhi); y++) { + + /*GD2_DBG(printf("y=%d: ",y)); */ + + xlo = cx * cs; + xhi = xlo + cs; + if (xhi > im->sx) { + xhi = im->sx; + }; + + if (gd2_compressed (fmt)) { + for (x = xlo; x < xhi; x++) { + /* 2.0.11: use truecolor pixel array. TBB */ + /*GD2_DBG(printf("%d...",x)); */ + if (im->trueColor) { + int p = im->tpixels[y][x]; + chunkData[chunkLen++] = gdTrueColorGetAlpha (p); + chunkData[chunkLen++] = gdTrueColorGetRed (p); + chunkData[chunkLen++] = gdTrueColorGetGreen (p); + chunkData[chunkLen++] = gdTrueColorGetBlue (p); + } else { + int p = im->pixels[y][x]; + chunkData[chunkLen++] = p; + } + }; + } else { + for (x = xlo; x < xhi; x++) { + /*GD2_DBG(printf("%d, ",x)); */ + + if (im->trueColor) { + gdPutInt (im->tpixels[y][x], out); + } else { + gdPutC ((unsigned char) im->pixels[y][x], out); + } + }; + }; + /*GD2_DBG(printf("y=%d done.\n",y)); */ + }; + if (gd2_compressed (fmt)) { + compLen = compMax; + if (compress ((unsigned char *) + &compData[0], &compLen, + (unsigned char *) &chunkData[0], + chunkLen) != Z_OK) { + printf ("Error from compressing\n"); + } else { + chunkIdx[chunkNum].offset = gdTell (out); + chunkIdx[chunkNum++].size = compLen; + GD2_DBG (printf + ("Chunk %d size %d offset %d\n", chunkNum, + chunkIdx[chunkNum - 1].size, + chunkIdx[chunkNum - 1].offset)); + + if (gdPutBuf (compData, compLen, out) <= 0) { + gd_error("gd write error\n"); + }; + }; + }; + }; + }; + if (gd2_compressed (fmt)) { + /* Save the position, write the index, restore position (paranoia). */ + GD2_DBG (printf ("Seeking %d to write index\n", idxPos)); + posSave = gdTell (out); + gdSeek (out, idxPos); + GD2_DBG (printf ("Writing index\n")); + for (x = 0; x < chunkNum; x++) { + GD2_DBG (printf + ("Chunk %d size %d offset %d\n", x, chunkIdx[x].size, + chunkIdx[x].offset)); + gdPutInt (chunkIdx[x].offset, out); + gdPutInt (chunkIdx[x].size, out); + }; + /* We don't use fwrite for *endian reasons. */ + /*fwrite(chunkIdx, sizeof(int)*2, chunkNum, out); */ + gdSeek (out, posSave); + }; + + /*printf("Memory block size is %d\n",gdTell(out)); */ +fail: + GD2_DBG (printf ("Freeing memory\n")); + + if (chunkData) { + gdFree (chunkData); + } + if (compData) { + gdFree (compData); + } + if (chunkIdx) { + gdFree (chunkIdx); + } + GD2_DBG (printf ("Done\n")); + +} + +BGD_DECLARE(void) gdImageGd2 (gdImagePtr im, FILE * outFile, int cs, int fmt) +{ + gdIOCtx *out = gdNewFileCtx (outFile); + if (out == NULL) return; + _gdImageGd2 (im, out, cs, fmt); + out->gd_free (out); +} + +BGD_DECLARE(void *) gdImageGd2Ptr (gdImagePtr im, int cs, int fmt, int *size) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx (2048, NULL); + if (out == NULL) return NULL; + _gdImageGd2 (im, out, cs, fmt); + rv = gdDPExtractData (out, size); + out->gd_free (out); + return rv; +} + +#else /* no HAVE_LIBZ */ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2 (FILE * inFile) +{ + gd_error("GD2 support is not available - no libz\n"); + return NULL; +} + +BGD_DECLARE(gdImagePtr) gdImageCreateFromGd2Ctx (gdIOCtxPtr in) +{ + gd_error("GD2 support is not available - no libz\n"); + return NULL; +} +#endif /* HAVE_LIBZ */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_gif_in.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_gif_in.c new file mode 100644 index 00000000000..3ae74dea523 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_gif_in.c @@ -0,0 +1,742 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include "gd.h" + +/* Used only when debugging GIF compression code */ +/* #define DEBUGGING_ENVARS */ + +#ifdef DEBUGGING_ENVARS + +static int verbose_set = 0; +static int verbose; + +#define VERBOSE (verbose_set ? verbose : set_verbose()) + +static int set_verbose(void) +{ + verbose = !!getenv("GIF_VERBOSE"); + verbose_set = 1; + return(verbose); +} + +#else + +#define VERBOSE 0 + +#endif + +#define MAXCOLORMAPSIZE 256 + +#define TRUE 1 +#define FALSE 0 + +#define CM_RED 0 +#define CM_GREEN 1 +#define CM_BLUE 2 + +#define MAX_LWZ_BITS 12 + +#define INTERLACE 0x40 +#define LOCALCOLORMAP 0x80 + +#define BitSet(byte, bit) (((byte) & (bit)) == (bit)) + +#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) > 0) + +#define LM_to_uint(a, b) (((b)<<8)|(a)) + +/* We may eventually want to use this information, but def it out for now */ +#if 0 +static struct { + unsigned int Width; + unsigned int Height; + unsigned char ColorMap[3][MAXCOLORMAPSIZE]; + unsigned int BitPixel; + unsigned int ColorResolution; + unsigned int Background; + unsigned int AspectRatio; +} GifScreen; +#endif + +#if 0 +static struct { + int transparent; + int delayTime; + int inputFlag; + int disposal; +} Gif89 = { -1, -1, -1, 0 }; +#endif + +#define STACK_SIZE ((1<<(MAX_LWZ_BITS))*2) + +#define CSD_BUF_SIZE 280 + +typedef struct { + unsigned char buf[CSD_BUF_SIZE]; + int curbit; + int lastbit; + int done; + int last_byte; +} CODE_STATIC_DATA; + +typedef struct { + int fresh; + int code_size, set_code_size; + int max_code, max_code_size; + int firstcode, oldcode; + int clear_code, end_code; + int table[2][(1<< MAX_LWZ_BITS)]; + int stack[STACK_SIZE], *sp; + CODE_STATIC_DATA scd; +} LZW_STATIC_DATA; + +static int ReadColorMap (gdIOCtx *fd, int number, unsigned char (*buffer)[256]); +static int DoExtension (gdIOCtx *fd, int label, int *Transparent, int *ZeroDataBlockP); +static int GetDataBlock (gdIOCtx *fd, unsigned char *buf, int *ZeroDataBlockP); +static int GetCode (gdIOCtx *fd, CODE_STATIC_DATA *scd, int code_size, int flag, int *ZeroDataBlockP); +static int LWZReadByte (gdIOCtx *fd, LZW_STATIC_DATA *sd, char flag, int input_code_size, int *ZeroDataBlockP); + +static void ReadImage (gdImagePtr im, gdIOCtx *fd, int len, int height, unsigned char (*cmap)[256], int interlace, int *ZeroDataBlockP); /*1.4//, int ignore); */ + +/* + Function: gdImageCreateFromGif + + <gdImageCreateFromGif> is called to load images from GIF format + files. Invoke <gdImageCreateFromGif> with an already opened + pointer to a file containing the desired + image. + + <gdImageCreateFromGif> returns a <gdImagePtr> to the new image, or + NULL if unable to load the image (most often because the file is + corrupt or does not contain a GIF image). <gdImageCreateFromGif> + does not close the file. You can inspect the sx and sy members of + the image to determine its size. The image must eventually be + destroyed using <gdImageDestroy>. + + Variants: + + <gdImageCreateFromGifPtr> creates an image from GIF data (i.e. the + contents of a GIF file) already in memory. + + <gdImageCreateFromGifCtx> reads in an image using the functions in + a <gdIOCtx> struct. + + Parameters: + + infile - The input FILE pointer + + Returns: + + A pointer to the new image or NULL if an error occurred. + + Example: + + > gdImagePtr im; + > ... inside a function ... + > FILE *in; + > in = fopen("mygif.gif", "rb"); + > im = gdImageCreateFromGif(in); + > fclose(in); + > // ... Use the image ... + > gdImageDestroy(im); + +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGif(FILE *fdFile) +{ + gdIOCtx *fd = gdNewFileCtx(fdFile); + gdImagePtr im; + + if (fd == NULL) return NULL; + im = gdImageCreateFromGifCtx(fd); + + fd->gd_free(fd); + + return im; +} + +/* + Function: gdImageCreateFromGifPtr + + Parameters: + + size - size of GIF data in bytes. + data - GIF data (i.e. contents of a GIF file). + + See <gdImageCreateFromGif>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGifPtr (int size, void *data) +{ + gdImagePtr im; + gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); + if(!in) { + return 0; + } + im = gdImageCreateFromGifCtx(in); + in->gd_free(in); + return im; +} + +/* + Function: gdImageCreateFromGifCtx + + See <gdImageCreateFromGif>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromGifCtx(gdIOCtxPtr fd) +{ + int BitPixel; +#if 0 + int ColorResolution; + int Background; + int AspectRatio; +#endif + int Transparent = (-1); + unsigned char buf[16]; + unsigned char c; + unsigned char ColorMap[3][MAXCOLORMAPSIZE]; + unsigned char localColorMap[3][MAXCOLORMAPSIZE]; + int imw, imh, screen_width, screen_height; + int useGlobalColormap; + int bitPixel, i; + /*1.4//int imageCount = 0; */ + /* 2.0.28: threadsafe storage */ + int ZeroDataBlock = FALSE; + int haveGlobalColormap; + + gdImagePtr im = 0; + + if(!ReadOK(fd, buf, 6)) { + return 0; + } + + if(strncmp((char *)buf, "GIF", 3) != 0) { + return 0; + } + + if(memcmp((char *)buf + 3, "87a", 3) == 0) { + /* GIF87a */ + } else if(memcmp((char *)buf + 3, "89a", 3) == 0) { + /* GIF89a */ + } else { + return 0; + } + + if(!ReadOK(fd, buf, 7)) { + return 0; + } + + BitPixel = 2 << (buf[4] & 0x07); +#if 0 + ColorResolution = (int) (((buf[4]&0x70)>>3)+1); + Background = buf[5]; + AspectRatio = buf[6]; +#endif + screen_width = imw = LM_to_uint(buf[0], buf[1]); + screen_height = imh = LM_to_uint(buf[2], buf[3]); + + haveGlobalColormap = BitSet(buf[4], LOCALCOLORMAP); /* Global Colormap */ + if(haveGlobalColormap) { + if(ReadColorMap(fd, BitPixel, ColorMap)) { + return 0; + } + } + + for (;;) { + int top, left; + int width, height; + + if(!ReadOK(fd, &c, 1)) { + return 0; + } + + if (c == ';') { /* GIF terminator */ + goto terminated; + } + + if(c == '!') { /* Extension */ + if(!ReadOK(fd, &c, 1)) { + return 0; + } + + DoExtension(fd, c, &Transparent, &ZeroDataBlock); + continue; + } + + if(c != ',') { /* Not a valid start character */ + continue; + } + + /*1.4//++imageCount; */ + + if(!ReadOK(fd, buf, 9)) { + return 0; + } + + useGlobalColormap = !BitSet(buf[8], LOCALCOLORMAP); + + bitPixel = 1 << ((buf[8] & 0x07) + 1); + left = LM_to_uint(buf[0], buf[1]); + top = LM_to_uint(buf[2], buf[3]); + width = LM_to_uint(buf[4], buf[5]); + height = LM_to_uint(buf[6], buf[7]); + + if(((left + width) > screen_width) || ((top + height) > screen_height)) { + if(VERBOSE) { + printf("Frame is not confined to screen dimension.\n"); + } + return 0; + } + + if(!(im = gdImageCreate(width, height))) { + return 0; + } + + im->interlace = BitSet(buf[8], INTERLACE); + if(!useGlobalColormap) { + if(ReadColorMap(fd, bitPixel, localColorMap)) { + gdImageDestroy(im); + return 0; + } + + ReadImage(im, fd, width, height, localColorMap, BitSet(buf[8], INTERLACE), &ZeroDataBlock); + } else { + if(!haveGlobalColormap) { + gdImageDestroy(im); + return 0; + } + + ReadImage(im, fd, width, height, ColorMap, BitSet(buf[8], INTERLACE), &ZeroDataBlock); + } + + if(Transparent != (-1)) { + gdImageColorTransparent(im, Transparent); + } + + goto terminated; + } + +terminated: + /* Terminator before any image was declared! */ + if(!im) { + return 0; + } + + if(!im->colorsTotal) { + gdImageDestroy(im); + return 0; + } + + /* Check for open colors at the end, so + * we can reduce colorsTotal and ultimately + * BitsPerPixel */ + for(i = im->colorsTotal - 1; i >= 0; i--) { + if(im->open[i]) { + im->colorsTotal--; + } else { + break; + } + } + + return im; +} + +static int +ReadColorMap(gdIOCtx *fd, int number, unsigned char (*buffer)[256]) +{ + int i; + unsigned char rgb[3]; + + for(i = 0; i < number; ++i) { + if(!ReadOK(fd, rgb, sizeof(rgb))) { + return TRUE; + } + + buffer[CM_RED][i] = rgb[0]; + buffer[CM_GREEN][i] = rgb[1]; + buffer[CM_BLUE][i] = rgb[2]; + } + + return FALSE; +} + +static int +DoExtension(gdIOCtx *fd, int label, int *Transparent, int *ZeroDataBlockP) +{ + unsigned char buf[256]; + + switch(label) { + case 0xf9: /* Graphic Control Extension */ + memset(buf, 0, 4); /* initialize a few bytes in the case the next function fails */ + (void) GetDataBlock(fd, (unsigned char*) buf, ZeroDataBlockP); +#if 0 + Gif89.disposal = (buf[0] >> 2) & 0x7; + Gif89.inputFlag = (buf[0] >> 1) & 0x1; + Gif89.delayTime = LM_to_uint(buf[1], buf[2]); +#endif + if((buf[0] & 0x1) != 0) { + *Transparent = buf[3]; + } + + while(GetDataBlock(fd, (unsigned char*) buf, ZeroDataBlockP) > 0); + + return FALSE; + + default: + break; + } + + while(GetDataBlock(fd, (unsigned char*) buf, ZeroDataBlockP) > 0); + + return FALSE; +} + +static int +GetDataBlock_(gdIOCtx *fd, unsigned char *buf, int *ZeroDataBlockP) +{ + unsigned char count; + + if(!ReadOK(fd, &count, 1)) { + return -1; + } + + *ZeroDataBlockP = count == 0; + + if((count != 0) && (!ReadOK(fd, buf, count))) { + return -1; + } + + return count; +} + +static int +GetDataBlock(gdIOCtx *fd, unsigned char *buf, int *ZeroDataBlockP) +{ + int rv, i; + + rv = GetDataBlock_(fd,buf, ZeroDataBlockP); + + if(VERBOSE) { + printf("[GetDataBlock returning %d",rv); + if(rv > 0) { + printf(":"); + for(i = 0; i < rv; i++) { + printf(" %02x",buf[i]); + } + } + printf("]\n"); + } + + return rv; +} + +static int +GetCode_(gdIOCtx *fd, CODE_STATIC_DATA *scd, int code_size, int flag, int *ZeroDataBlockP) +{ + int i, j, ret; + unsigned char count; + + if(flag) { + scd->curbit = 0; + scd->lastbit = 0; + scd->last_byte = 0; + scd->done = FALSE; + return 0; + } + + if((scd->curbit + code_size) >= scd->lastbit) { + if(scd->done) { + if(scd->curbit >= scd->lastbit) { + /* Oh well */ + } + return -1; + } + + scd->buf[0] = scd->buf[scd->last_byte - 2]; + scd->buf[1] = scd->buf[scd->last_byte - 1]; + + if((count = GetDataBlock(fd, &scd->buf[2], ZeroDataBlockP)) <= 0) { + scd->done = TRUE; + } + + scd->last_byte = 2 + count; + scd->curbit = (scd->curbit - scd->lastbit) + 16; + scd->lastbit = (2 + count) * 8; + } + + if ((scd->curbit + code_size - 1) >= (CSD_BUF_SIZE * 8)) { + ret = -1; + } else { + ret = 0; + for (i = scd->curbit, j = 0; j < code_size; ++i, ++j) { + ret |= ((scd->buf[i / 8] & (1 << (i % 8))) != 0) << j; + } + } + + scd->curbit += code_size; + + return ret; +} + +static int +GetCode(gdIOCtx *fd, CODE_STATIC_DATA *scd, int code_size, int flag, int *ZeroDataBlockP) +{ + int rv; + + rv = GetCode_(fd, scd, code_size,flag, ZeroDataBlockP); + + if(VERBOSE) { + printf("[GetCode(,%d,%d) returning %d]\n",code_size,flag,rv); + } + + return rv; +} + +static int +LWZReadByte_(gdIOCtx *fd, LZW_STATIC_DATA *sd, char flag, int input_code_size, int *ZeroDataBlockP) +{ + int code, incode, i; + + if(flag) { + sd->set_code_size = input_code_size; + sd->code_size = sd->set_code_size + 1; + sd->clear_code = 1 << sd->set_code_size; + sd->end_code = sd->clear_code + 1; + sd->max_code_size = 2 * sd->clear_code; + sd->max_code = sd->clear_code + 2; + + GetCode(fd, &sd->scd, 0, TRUE, ZeroDataBlockP); + + sd->fresh = TRUE; + + for(i = 0; i < sd->clear_code; ++i) { + sd->table[0][i] = 0; + sd->table[1][i] = i; + } + + for(; i < (1 << MAX_LWZ_BITS); ++i) { + sd->table[0][i] = sd->table[1][0] = 0; + } + + sd->sp = sd->stack; + + return 0; + + } else if(sd->fresh) { + sd->fresh = FALSE; + + do { + sd->firstcode = sd->oldcode = + GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP); + } while(sd->firstcode == sd->clear_code); + + return sd->firstcode; + } + + if(sd->sp > sd->stack) { + return *--sd->sp; + } + + while((code = GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP)) >= 0) { + if(code == sd->clear_code) { + for(i = 0; i < sd->clear_code; ++i) { + sd->table[0][i] = 0; + sd->table[1][i] = i; + } + + for (; i < (1 << MAX_LWZ_BITS); ++i) { + sd->table[0][i] = sd->table[1][i] = 0; + } + + sd->code_size = sd->set_code_size + 1; + sd->max_code_size = 2 * sd->clear_code; + sd->max_code = sd->clear_code + 2; + sd->sp = sd->stack; + sd->firstcode = sd->oldcode = + GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP); + + return sd->firstcode; + } else if(code == sd->end_code) { + int count; + unsigned char buf[260]; + + if(*ZeroDataBlockP) { + return -2; + } + + while((count = GetDataBlock(fd, buf, ZeroDataBlockP)) > 0); + + if(count != 0) { + return -2; + } + } + + incode = code; + + if(sd->sp == (sd->stack + STACK_SIZE)) { + /* Bad compressed data stream */ + return -1; + } + + if(code >= sd->max_code) { + *sd->sp++ = sd->firstcode; + code = sd->oldcode; + } + + while(code >= sd->clear_code) { + if(sd->sp == (sd->stack + STACK_SIZE)) { + /* Bad compressed data stream */ + return -1; + } + + *sd->sp++ = sd->table[1][code]; + + if(code == sd->table[0][code]) { + /* Oh well */ + } + + code = sd->table[0][code]; + } + + *sd->sp++ = sd->firstcode = sd->table[1][code]; + + if((code = sd->max_code) < (1 << MAX_LWZ_BITS)) { + sd->table[0][code] = sd->oldcode; + sd->table[1][code] = sd->firstcode; + ++sd->max_code; + + if((sd->max_code >= sd->max_code_size) && (sd->max_code_size < (1<<MAX_LWZ_BITS))) { + sd->max_code_size *= 2; + ++sd->code_size; + } + } + + sd->oldcode = incode; + + if(sd->sp > sd->stack) { + return *--sd->sp; + } + } + + return code; +} + +static int +LWZReadByte(gdIOCtx *fd, LZW_STATIC_DATA *sd, char flag, int input_code_size, int *ZeroDataBlockP) +{ + int rv; + + rv = LWZReadByte_(fd, sd, flag, input_code_size, ZeroDataBlockP); + + if(VERBOSE) { + printf("[LWZReadByte(,%d,%d) returning %d]\n",flag,input_code_size,rv); + } + + return rv; +} + +static void +ReadImage(gdImagePtr im, gdIOCtx *fd, int len, int height, unsigned char (*cmap)[256], int interlace, int *ZeroDataBlockP) /*1.4//, int ignore) */ +{ + unsigned char c; + int xpos = 0, ypos = 0, pass = 0; + int v, i; + LZW_STATIC_DATA sd; + + /* Initialize the Compression routines */ + if(!ReadOK(fd, &c, 1)) { + return; + } + + if(c > MAX_LWZ_BITS) { + return; + } + + /* Stash the color map into the image */ + for(i=0; (i < gdMaxColors); i++) { + im->red[i] = cmap[CM_RED][i]; + im->green[i] = cmap[CM_GREEN][i]; + im->blue[i] = cmap[CM_BLUE][i]; + im->open[i] = 1; + } + + /* Many (perhaps most) of these colors will remain marked open. */ + im->colorsTotal = gdMaxColors; + if(LWZReadByte(fd, &sd, TRUE, c, ZeroDataBlockP) < 0) { + return; + } + + /* + ** If this is an "uninteresting picture" ignore it. + ** REMOVED For 1.4 + */ + /*if (ignore) { */ + /* while (LWZReadByte(fd, &sd, FALSE, c) >= 0) */ + /* ; */ + /* return; */ + /*} */ + + while((v = LWZReadByte(fd, &sd, FALSE, c, ZeroDataBlockP)) >= 0 ) { + if(v >= gdMaxColors) { + v = 0; + } + + /* This how we recognize which colors are actually used. */ + if(im->open[v]) { + im->open[v] = 0; + } + + gdImageSetPixel(im, xpos, ypos, v); + + ++xpos; + if(xpos == len) { + xpos = 0; + if(interlace) { + switch (pass) { + case 0: + case 1: + ypos += 8; + break; + case 2: + ypos += 4; + break; + case 3: + ypos += 2; + break; + } + + if(ypos >= height) { + ++pass; + switch (pass) { + case 1: + ypos = 4; + break; + case 2: + ypos = 2; + break; + case 3: + ypos = 1; + break; + default: + goto fini; + } + } + } else { + ++ypos; + } + } + + if(ypos >= height) { + break; + } + } + +fini: + if(LWZReadByte(fd, &sd, FALSE, c, ZeroDataBlockP) >=0) { + /* Ignore extra */ + } +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_gif_out.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_gif_out.c new file mode 100644 index 00000000000..51ceb753855 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_gif_out.c @@ -0,0 +1,1588 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" + +/* Code drawn from ppmtogif.c, from the pbmplus package +** +** Based on GIFENCOD by David Rowley <mgardi@watdscu.waterloo.edu>. A +** Lempel-Zim compression based on "compress". +** +** Modified by Marcel Wijkstra <wijkstra@fwi.uva.nl> +** +** Copyright (C) 1989 by Jef Poskanzer. +** +** Permission to use, copy, modify, and distribute this software and its +** documentation for any purpose and without fee is hereby granted, provided +** that the above copyright notice appear in all copies and that both that +** copyright notice and this permission notice appear in supporting +** documentation. This software is provided "as is" without express or +** implied warranty. +** +** The Graphics Interchange Format(c) is the Copyright property of +** CompuServe Incorporated. GIF(sm) is a Service Mark property of +** CompuServe Incorporated. +*/ + +/* a code_int must be able to hold 2**GIFBITS values of type int, and also -1 */ +typedef int code_int; + +#ifdef SIGNED_COMPARE_SLOW +typedef unsigned long int count_int; +typedef unsigned short int count_short; +#else /* SIGNED_COMPARE_SLOW */ +typedef long int count_int; +#endif /* SIGNED_COMPARE_SLOW */ + +/* 2.0.28: threadsafe */ + +#define maxbits GIFBITS + +/* should NEVER generate this code */ +#define maxmaxcode ((code_int)1 << GIFBITS) + +#define HSIZE 5003 /* 80% occupancy */ +#define hsize HSIZE /* Apparently invariant, left over from compress */ + +typedef struct { + int Width, Height; + int curx, cury; + long CountDown; + int Pass; + int Interlace; + int n_bits; + code_int maxcode; + count_int htab [HSIZE]; + unsigned short codetab [HSIZE]; + /* first unused entry */ + code_int free_ent; + /* block compression parameters -- after all codes are used up, + * and compression rate changes, start over. */ + int clear_flg; + int offset; + long int in_count; + /* # of codes output (for debugging) */ + long int out_count; + int g_init_bits; + gdIOCtx * g_outfile; + int ClearCode; + int EOFCode; + unsigned long cur_accum; + int cur_bits; + int a_count; + char accum[ 256 ]; +} GifCtx; + +static int gifPutWord(int w, gdIOCtx *out); +static int colorstobpp(int colors); +static void BumpPixel(GifCtx *ctx); +static int GIFNextPixel(gdImagePtr im, GifCtx *ctx); +static void GIFEncode(gdIOCtxPtr fp, int GWidth, int GHeight, int GInterlace, int Background, int Transparent, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im); +static void GIFAnimEncode(gdIOCtxPtr fp, int IWidth, int IHeight, int LeftOfs, int TopOfs, int GInterlace, int Transparent, int Delay, int Disposal, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im); +static void compress(int init_bits, gdIOCtx *outfile, gdImagePtr im, GifCtx *ctx); +static void output(code_int code, GifCtx *ctx); +static void cl_block(GifCtx *ctx); +static void cl_hash(register count_int chsize, GifCtx *ctx); +static void char_init(GifCtx *ctx); +static void char_out(int c, GifCtx *ctx); +static void flush_char(GifCtx *ctx); + + + + +/* + Function: gdImageGifPtr + + Identical to <gdImageGif> except that it returns a pointer to a + memory area with the GIF data. This memory must be freed by the + caller when it is no longer needed. + + The caller *must* invoke <gdFree>, not _free()_. This is because + it is not guaranteed that libgd will use the same implementation + of malloc, free, etc. as your proggram. + + The 'size' parameter receives the total size of the block of + memory. + + Parameters: + + im - The image to write + size - Output: the size of the resulting image. + + Returns: + + A pointer to the GIF data or NULL if an error occurred. + +*/ +BGD_DECLARE(void *) gdImageGifPtr(gdImagePtr im, int *size) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx(2048, NULL); + if (out == NULL) return NULL; + gdImageGifCtx(im, out); + rv = gdDPExtractData(out, size); + out->gd_free(out); + return rv; +} + +/* + Function: gdImageGif + + <gdImageGif> outputs the specified image to the specified file in + GIF format. The file must be open for binary writing. (Under MSDOS + and all versions of Windows, it is important to use "wb" as + opposed to simply "w" as the mode when opening the file; under + Unix there is no penalty for doing so). <gdImageGif> does not close + the file; your code must do so. + + GIF does not support true color; GIF images can contain a maximum + of 256 colors. If the image to be written is a truecolor image, + such as those created with gdImageCreateTrueColor or loaded from a + JPEG or a truecolor PNG image file, a palette-based temporary + image will automatically be created internally using the + <gdImageCreatePaletteFromTrueColor> function. The original image + pixels are not modified. This conversion produces high quality + palettes but does require some CPU time. If you are regularly + converting truecolor to palette in this way, you should consider + creating your image as a palette-based image in the first place. + + Variants: + + <gdImageGifCtx> outputs the image via a <gdIOCtx> struct. + + <gdImageGifPtr> stores the image in a large array of bytes. + + Parameters: + + im - The image to write + outFile - The FILE pointer to write the image to. + + Returns: + + Nothing + + Example: + + > gdImagePtr im; + > int black, white; + > FILE *out; + > // Create the image + > im = gdImageCreate(100, 100); + > // Allocate background + > white = gdImageColorAllocate(im, 255, 255, 255); + > // Allocate drawing color + > black = gdImageColorAllocate(im, 0, 0, 0); + > // Draw rectangle + > gdImageRectangle(im, 0, 0, 99, 99, black); + > // Open output file in binary mode + > out = fopen("rect.gif", "wb"); + > // Write GIF + > gdImageGif(im, out); + > // Close file + > fclose(out); + > // Destroy image + > gdImageDestroy(im); + +*/ +BGD_DECLARE(void) gdImageGif(gdImagePtr im, FILE *outFile) +{ + gdIOCtx *out = gdNewFileCtx(outFile); + if (out == NULL) return; + gdImageGifCtx(im, out); + out->gd_free(out); +} + +/* + Function: gdImageGifCtx + + Writes a GIF image via a <gdIOCtx>. See <gdImageGif>. + + Parameters: + + im - The image to write + out - The <gdIOCtx> struct used to do the writing. + + Returns: + + Nothing. + +*/ +BGD_DECLARE(void) gdImageGifCtx(gdImagePtr im, gdIOCtxPtr out) +{ + gdImagePtr pim = 0, tim = im; + int interlace, BitsPerPixel; + interlace = im->interlace; + + if(im->trueColor) { + /* Expensive, but the only way that produces an + acceptable result: mix down to a palette + based temporary image. */ + pim = gdImageCreatePaletteFromTrueColor(im, 1, 256); + if(!pim) { + return; + } + tim = pim; + } + + BitsPerPixel = colorstobpp(tim->colorsTotal); + + /* All set, let's do it. */ + GIFEncode( + out, tim->sx, tim->sy, interlace, 0, tim->transparent, BitsPerPixel, + tim->red, tim->green, tim->blue, tim); + + if(pim) { + /* Destroy palette based temporary image. */ + gdImageDestroy( pim); + } +} + + +/* + Function: gdImageGifAnimBeginPtr + + Like <gdImageGifAnimBegin> except that it outputs to a memory + buffer. See <gdImageGifAnimBegin>. + + The returned memory must be freed by the caller when it is no + longer needed. **The caller must invoke <gdFree>(), not free()**, + unless the caller is absolutely certain that the same + implementations of malloc, free, etc. are used both at library + build time and at application build time (but don't; it could + always change). + + The 'size' parameter receives the total size of the block of + memory. + + Parameters: + + im - The reference image + size - Output: the size in bytes of the result. + GlobalCM - Global colormap flag: 1 -> yes, 0 -> no, -1 -> do default + Loops - Loop count; 0 -> infinite, -1 means no loop + + Returns: + + A pointer to the resulting data (the contents of the start of the + GIF) or NULL if an error occurred. + +*/ + +BGD_DECLARE(void *) gdImageGifAnimBeginPtr(gdImagePtr im, int *size, int GlobalCM, int Loops) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx(2048, NULL); + if (out == NULL) return NULL; + gdImageGifAnimBeginCtx(im, out, GlobalCM, Loops); + rv = gdDPExtractData(out, size); + out->gd_free(out); + return rv; +} + + +/* + Function: gdImageGifAnimBegin + + This function must be called as the first function when creating a + GIF animation. It writes the correct GIF file headers to selected + file output, and prepares for frames to be added for the + animation. The image argument is not used to produce an image + frame to the file, it is only used to establish the GIF animation + frame size, interlacing options and the color + palette. <gdImageGifAnimAdd> is used to add the first and + subsequent frames to the animation, and the animation must be + terminated by writing a semicolon character (;) to it or by using + gdImageGifAnimEnd to do that. + + The GlobalCM flag indicates if a global color map (or palette) is + used in the GIF89A header. A nonzero value specifies that a global + color map should be used to reduce the size of the animation. Of + course, if the color maps of individual frames differ greatly, a + global color map may not be a good idea. GlobalCM=1 means write + global color map, GlobalCM=0 means do not, and GlobalCM=-1 means + to do the default, which currently is to use a global color map. + + If Loops is 0 or greater, the Netscape 2.0 extension for animation + loop count is written. 0 means infinite loop count. -1 means that + the extension is not added which results in no looping. -1 is the + default. + + Variants: + + <gdImageGifAnimBeginCtx> outputs the image via a <gdIOCtx> struct. + + <gdImageGifAnimBeginPtr> stores the image in a large array of bytes. + + Parameters: + + im - The reference image + outfile - The output FILE*. + GlobalCM - Global colormap flag: 1 -> yes, 0 -> no, -1 -> do default + Loops - Loop count; 0 -> infinite, -1 means no loop + + Returns: + + Nothing. + + Example: + + See <gdImageGifAnimBegin>. + +*/ + +BGD_DECLARE(void) gdImageGifAnimBegin(gdImagePtr im, FILE *outFile, int GlobalCM, int Loops) +{ + gdIOCtx *out = gdNewFileCtx(outFile); + if (out == NULL) return; + gdImageGifAnimBeginCtx(im, out, GlobalCM, Loops); + out->gd_free(out); +} + + + +/* + Function: gdImageGifAnimBeginCtx + + Like <gdImageGifAnimBegin> except that it outputs to <gdIOCtx>. + See <gdImageGifAnimBegin>. + + Parameters: + + im - The reference image + out - Pointer to the output <gdIOCtx>. + GlobalCM - Global colormap flag: 1 -> yes, 0 -> no, -1 -> do default + Loops - Loop count; 0 -> infinite, -1 means no loop + + Returns: + + Nothing. + +*/ +BGD_DECLARE(void) gdImageGifAnimBeginCtx(gdImagePtr im, gdIOCtxPtr out, int GlobalCM, int Loops) +{ + int B; + int RWidth, RHeight; + int Resolution; + int ColorMapSize; + int BitsPerPixel; + int Background = 0; + int i; + + /* Default is to use global color map */ + if (GlobalCM < 0) { + GlobalCM = 1; + } + + BitsPerPixel = colorstobpp(im->colorsTotal); + ColorMapSize = 1 << BitsPerPixel; + + RWidth = im->sx; + RHeight = im->sy; + + Resolution = BitsPerPixel; + + /* Write the Magic header */ + gdPutBuf("GIF89a", 6, out); + + /* Write out the screen width and height */ + gifPutWord(RWidth, out); + gifPutWord(RHeight, out); + + /* Indicate that there is a global colour map */ + B = GlobalCM ? 0x80 : 0; + + /* OR in the resolution */ + B |= (Resolution - 1) << 4; + + /* OR in the Bits per Pixel */ + B |= (BitsPerPixel - 1); + + /* Write it out */ + gdPutC(B, out); + + /* Write out the Background colour */ + gdPutC(Background, out); + + /* Byte of 0's (future expansion) */ + gdPutC(0, out); + + /* Write out the Global Colour Map */ + if(GlobalCM) { + for(i = 0; i < ColorMapSize; ++i) { + gdPutC(im->red[i], out); + gdPutC(im->green[i], out); + gdPutC(im->blue[i], out); + } + } + + if(Loops >= 0) { + gdPutBuf("!\377\13NETSCAPE2.0\3\1", 16, out); + gifPutWord(Loops, out); + gdPutC(0, out); + } +} + + + +/* + Function: gdImageGifAnimAddPtr + + Like <gdImageGifAnimAdd> (which contains more information) except + that it stores the data to write into memory and returns a pointer + to it. + + This memory must be freed by the caller when it is no longer + needed. **The caller must invoke <gdFree>(), not free(),** unless + the caller is absolutely certain that the same implementations of + malloc, free, etc. are used both at library build time and at + application build time (but don't; it could always change). + + The 'size' parameter receives the total size of the block of + memory. + + Parameters: + + im - The image to add. + size - Output: the size of the resulting buffer. + LocalCM - Flag. If 1, use a local color map for this frame. + LeftOfs - Left offset of image in frame. + TopOfs - Top offset of image in frame. + Delay - Delay before next frame (in 1/100 seconds) + Disposal - MODE: How to treat this frame when the next one loads. + previm - NULL or a pointer to the previous image written. + + Returns: + + Pointer to the resulting data or NULL if an error occurred. + +*/ +BGD_DECLARE(void *) gdImageGifAnimAddPtr(gdImagePtr im, int *size, int LocalCM, + int LeftOfs, int TopOfs, int Delay, + int Disposal, gdImagePtr previm) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx(2048, NULL); + if (out == NULL) return NULL; + gdImageGifAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm); + rv = gdDPExtractData(out, size); + out->gd_free(out); + return rv; +} + + +/* + Function: gdImageGifAnimAdd + + This function writes GIF animation frames to GIF animation, which + was initialized with <gdImageGifAnimBegin>. With _LeftOfs_ and + _TopOfs_ you can place this frame in different offset than (0,0) + inside the image screen as defined in <gdImageGifAnimBegin>. Delay + between the previous frame and this frame is in 1/100s + units. _Disposal_ is usually <gdDisposalNone>, meaning that the + pixels changed by this frame should remain on the display when the + next frame begins to render, but can also be <gdDisposalUnknown> + (not recommended), <gdDisposalRestoreBackground> (restores the + first allocated color of the global palette), or + <gdDisposalRestorePrevious> (restores the appearance of the + affected area before the frame was rendered). Only + <gdDisposalNone> is a sensible choice for the first frame. If + _previm_ is passed, the built-in GIF optimizer will always use + <gdDisposalNone> regardless of the Disposal parameter. + + Setting the _LocalCM_ flag to 1 adds a local palette for this + image to the animation. Otherwise the global palette is assumed + and the user must make sure the palettes match. Use + <gdImagePaletteCopy> to do that. + + Automatic optimization is activated by giving the previous image + as a parameter. This function then compares the images and only + writes the changed pixels to the new frame in animation. The + _Disposal_ parameter for optimized animations must be set to 1, + also for the first frame. _LeftOfs_ and _TopOfs_ parameters are + ignored for optimized frames. To achieve good optimization, it is + usually best to use a single global color map. To allow + <gdImageGifAnimAdd> to compress unchanged pixels via the use of a + transparent color, the image must include a transparent color. + + + Variants: + + <gdImageGifAnimAddCtx> outputs its data via a <gdIOCtx> struct. + + <gdImageGifAnimAddPtr> outputs its data to a memory buffer which + it returns. + + Parameters: + + im - The image to add. + outfile - The output FILE* being written. + LocalCM - Flag. If 1, use a local color map for this frame. + LeftOfs - Left offset of image in frame. + TopOfs - Top offset of image in frame. + Delay - Delay before next frame (in 1/100 seconds) + Disposal - MODE: How to treat this frame when the next one loads. + previm - NULL or a pointer to the previous image written. + + Returns: + + Nothing. + + Example: + + > { + > gdImagePtr im, im2, im3; + > int black, white, trans; + > FILE *out; + > + > im = gdImageCreate(100, 100); // Create the image + > white = gdImageColorAllocate(im, 255, 255, 255); // Allocate background + > black = gdImageColorAllocate(im, 0, 0, 0); // Allocate drawing color + > trans = gdImageColorAllocate(im, 1, 1, 1); // trans clr for compression + > gdImageRectangle(im, 0, 0, 10, 10, black); // Draw rectangle + > + > out = fopen("anim.gif", "wb");// Open output file in binary mode + > gdImageGifAnimBegin(im, out, 1, 3);// Write GIF hdr, global clr map,loops + > // Write the first frame. No local color map. Delay = 1s + > gdImageGifAnimAdd(im, out, 0, 0, 0, 100, 1, NULL); + > + > // construct the second frame + > im2 = gdImageCreate(100, 100); + > (void)gdImageColorAllocate(im2, 255, 255, 255); // White background + > gdImagePaletteCopy (im2, im); // Make sure the palette is identical + > gdImageRectangle(im2, 0, 0, 15, 15, black); // Draw something + > // Allow animation compression with transparent pixels + > gdImageColorTransparent (im2, trans); + > gdImageGifAnimAdd(im2, out, 0, 0, 0, 100, 1, im); // Add second frame + > + > // construct the third frame + > im3 = gdImageCreate(100, 100); + > (void)gdImageColorAllocate(im3, 255, 255, 255); // white background + > gdImagePaletteCopy (im3, im); // Make sure the palette is identical + > gdImageRectangle(im3, 0, 0, 15, 20, black); // Draw something + > // Allow animation compression with transparent pixels + > gdImageColorTransparent (im3, trans); + > // Add the third frame, compressing against the second one + > gdImageGifAnimAdd(im3, out, 0, 0, 0, 100, 1, im2); + > gdImageGifAnimEnd(out); // End marker, same as putc(';', out); + > fclose(out); // Close file + > + > // Destroy images + > gdImageDestroy(im); + > gdImageDestroy(im2); + > gdImageDestroy(im3); + > } + +*/ + +BGD_DECLARE(void) gdImageGifAnimAdd(gdImagePtr im, FILE *outFile, int LocalCM, + int LeftOfs, int TopOfs, int Delay, + int Disposal, gdImagePtr previm) +{ + gdIOCtx *out = gdNewFileCtx(outFile); + if (out == NULL) return; + gdImageGifAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm); + out->gd_free(out); +} + +static int comparewithmap(gdImagePtr im1, gdImagePtr im2, int c1, int c2, int *colorMap) +{ + if(!colorMap) { + return c1 == c2; + } + + if(-2 != colorMap[c1]) { + return colorMap[c1] == c2; + } + + return (colorMap[c1] = gdImageColorExactAlpha(im2, im1->red[c1], im1->green[c1], im1->blue[c1], im1->alpha[c1])) == c2; +} + +/* + Function: gdImageGifAnimAddCtx + + Adds an animation frame via a <gdIOCtxPtr>. See gdImageGifAnimAdd>. + + Parameters: + + im - The image to add. + out - The output <gdIOCtxPtr>. + LocalCM - Flag. If 1, use a local color map for this frame. + LeftOfs - Left offset of image in frame. + TopOfs - Top offset of image in frame. + Delay - Delay before next frame (in 1/100 seconds) + Disposal - MODE: How to treat this frame when the next one loads. + previm - NULL or a pointer to the previous image written. + + Returns: + + Nothing. + +*/ +BGD_DECLARE(void) gdImageGifAnimAddCtx(gdImagePtr im, gdIOCtxPtr out, + int LocalCM, int LeftOfs, int TopOfs, + int Delay, int Disposal, + gdImagePtr previm) +{ + gdImagePtr pim = NULL, tim = im; + int interlace, transparent, BitsPerPixel; + interlace = im->interlace; + transparent = im->transparent; + + /* Default is no local color map */ + if(LocalCM < 0) { + LocalCM = 0; + } + + if(im->trueColor) { + /* Expensive, but the only way that produces an + acceptable result: mix down to a palette + based temporary image. */ + pim = gdImageCreatePaletteFromTrueColor(im, 1, 256); + if (!pim) { + return; + } + tim = pim; + } + + if (previm) { + /* create optimized animation. Compare this image to + the previous image and crop the temporary copy of + current image to include only changed rectangular + area. Also replace unchanged pixels inside this + area with transparent color. Transparent color + needs to be already allocated! + Preconditions: + TopOfs, LeftOfs are assumed 0 + + Images should be of same size. If not, a temporary + copy is made with the same size as previous image. + + */ + gdImagePtr prev_pim = 0, prev_tim = previm; + int x, y; + int min_x = 0; + int min_y = tim->sy; + int max_x = 0; + int max_y = 0; + int colorMap[256]; + + if (previm->trueColor) { + prev_pim = gdImageCreatePaletteFromTrueColor(previm, 1, 256); + if (!prev_pim) { + goto fail_end; + } + prev_tim = prev_pim; + } + + for (x = 0; x < 256; ++x) { + colorMap[x] = -2; + } + + /* First find bounding box of changed areas. */ + /* first find the top changed row */ + for (y = 0; y < tim->sy; ++y) { + for (x = 0; x < tim->sx; ++x) { + if (!comparewithmap(prev_tim, tim, + prev_tim->pixels[y][x], + tim->pixels[y][x], + colorMap)) { + min_y = max_y = y; + min_x = max_x = x; + goto break_top; + } + } + } + +break_top: + if (tim->sy == min_y) { + /* No changes in this frame!! Encode empty image. */ + transparent = 0; + min_x = min_y = 1; + max_x = max_y = 0; + } else { + /* Then the bottom row */ + for (y = tim->sy - 1; y > min_y; --y) { + for (x = 0; x < tim->sx; ++x) { + if (!comparewithmap + (prev_tim, tim, + prev_tim->pixels[y][x], + tim->pixels[y][x], + colorMap)) { + max_y = y; + if(x < min_x) { + min_x = x; + } + if(x > max_x) { + max_x = x; + } + goto break_bot; + } + } + } + +break_bot: + /* left side */ + for (x = 0; x < min_x; ++x) { + for (y = min_y; y <= max_y; ++y) { + if (!comparewithmap + (prev_tim, tim, + prev_tim->pixels[y][x], + tim->pixels[y][x], + colorMap)) { + min_x = x; + goto break_left; + } + } + } + +break_left: + /* right side */ + for (x = tim->sx - 1; x > max_x; --x) { + for (y = min_y; y <= max_y; ++y) { + if (!comparewithmap + (prev_tim, tim, + prev_tim->pixels[y][x], + tim->pixels[y][x], + colorMap)) { + max_x = x; + goto break_right; + } + } + } + +break_right: + ; + } + + LeftOfs = min_x; + TopOfs = min_y; + Disposal = 1; + + /* Make a copy of the image with the new offsets. + But only if necessary. */ + if (min_x != 0 || max_x != tim->sx - 1 + || min_y != 0 || max_y != tim->sy - 1 + || transparent >= 0) { + + gdImagePtr pim2 = gdImageCreate(max_x-min_x + 1, max_y-min_y + 1); + + if (!pim2) { + if (prev_pim) { + gdImageDestroy(prev_pim); + } + goto fail_end; + } + + gdImagePaletteCopy(pim2, LocalCM ? tim : prev_tim); + gdImageCopy(pim2, tim, 0, 0, min_x, min_y, + max_x - min_x + 1, max_y - min_y + 1); + + if (pim) { + gdImageDestroy(pim); + } + + tim = pim = pim2; + } + + /* now let's compare pixels for transparent + optimization. But only if transparent is set. */ + if (transparent >= 0) { + for(y = 0; y < tim->sy; ++y) { + for (x = 0; x < tim->sx; ++x) { + if(comparewithmap + (prev_tim, tim, + prev_tim->pixels[min_y + y][min_x + x], + tim->pixels[y][x], 0)) { + gdImageSetPixel(tim, x, y, transparent); + break; + } + } + } + } + + if(prev_pim) { + gdImageDestroy(prev_pim); + } + } + + BitsPerPixel = colorstobpp(tim->colorsTotal); + + /* All set, let's do it. */ + GIFAnimEncode( + out, tim->sx, tim->sy, LeftOfs, TopOfs, interlace, transparent, + Delay, Disposal, BitsPerPixel, + LocalCM ? tim->red : 0, tim->green, tim->blue, tim); + +fail_end: + if(pim) { + /* Destroy palette based temporary image. */ + gdImageDestroy(pim); + } +} + + + +/* + Function: gdImageGifAnimEnd + + Terminates the GIF file properly. + + (Previous versions of this function's documentation suggested just + manually writing a semicolon (';') instead since that is all this + function does. While that has no longer changed, we now suggest + that you do not do this and instead always call + <gdImageGifAnimEnd> (or equivalent) since later versions could + possibly do more or different things.) + + Variants: + + <gdImageGifAnimEndCtx> outputs its data via a <gdIOCtx> struct. + + <gdImageGifAnimEndPtr> outputs its data to a memory buffer which + it returns. + + Parameters: + + outfile - the destination FILE*. + + Returns: + + Nothing. + +*/ + +BGD_DECLARE(void) gdImageGifAnimEnd(FILE *outFile) +{ +#if 1 + putc(';', outFile); +#else + gdIOCtx *out = gdNewFileCtx(outFile); + if (out == NULL) return; + gdImageGifAnimEndCtx(out); + out->gd_free(out); +#endif +} + +/* + Function: gdImageGifAnimEndPtr + + Like <gdImageGifAnimEnd> (which contains more information) except + that it stores the data to write into memory and returns a pointer + to it. + + This memory must be freed by the caller when it is no longer + needed. **The caller must invoke <gdFree>(), not free(),** unless + the caller is absolutely certain that the same implementations of + malloc, free, etc. are used both at library build time and at + application build time (but don't; it could always change). + + The 'size' parameter receives the total size of the block of + memory. + + Parameters: + + size - Output: the size of the resulting buffer. + + Returns: + + Pointer to the resulting data or NULL if an error occurred. + +*/ + +BGD_DECLARE(void *) gdImageGifAnimEndPtr(int *size) +{ + char *rv = (char *) gdMalloc(1); + if(!rv) { + return 0; + } + *rv = ';'; + *size = 1; + return (void *)rv; +} + +/* + Function: gdImageGifAnimEndCtx + + Like <gdImageGifAnimEnd>, but writes its data via a <gdIOCtx>. + + Parameters: + + out - the destination <gdIOCtx>. + + Returns: + + Nothing. + +*/ + +BGD_DECLARE(void) gdImageGifAnimEndCtx(gdIOCtx *out) +{ + /* + * Write the GIF file terminator + */ + gdPutC(';', out); +} + +static int colorstobpp(int colors) +{ + int bpp = 0; + + if(colors <= 2) + bpp = 1; + else if(colors <= 4) + bpp = 2; + else if(colors <= 8) + bpp = 3; + else if(colors <= 16) + bpp = 4; + else if(colors <= 32) + bpp = 5; + else if(colors <= 64) + bpp = 6; + else if(colors <= 128) + bpp = 7; + else if(colors <= 256) + bpp = 8; + + return bpp; +} + +/***************************************************************************** + * + * GIFENCODE.C - GIF Image compression interface + * + * GIFEncode( FName, GHeight, GWidth, GInterlace, Background, Transparent, + * BitsPerPixel, Red, Green, Blue, gdImagePtr ) + * + *****************************************************************************/ + +#define TRUE 1 +#define FALSE 0 + +/* Bump the 'curx' and 'cury' to point to the next pixel */ +static void BumpPixel(GifCtx *ctx) +{ + /* Bump the current X position */ + ++(ctx->curx); + + /* If we are at the end of a scan line, set curx back to the beginning + * If we are interlaced, bump the cury to the appropriate spot, + * otherwise, just increment it. */ + if(ctx->curx == ctx->Width) { + ctx->curx = 0; + + if(!ctx->Interlace) { + ++(ctx->cury); + } else { + switch(ctx->Pass) { + + case 0: + ctx->cury += 8; + if(ctx->cury >= ctx->Height) { + ++(ctx->Pass); + ctx->cury = 4; + } + break; + + case 1: + ctx->cury += 8; + if(ctx->cury >= ctx->Height) { + ++(ctx->Pass); + ctx->cury = 2; + } + break; + + case 2: + ctx->cury += 4; + if(ctx->cury >= ctx->Height) { + ++(ctx->Pass); + ctx->cury = 1; + } + break; + + case 3: + ctx->cury += 2; + break; + } + } + } +} + +/* Return the next pixel from the image */ +static int GIFNextPixel(gdImagePtr im, GifCtx *ctx) +{ + int r; + + if(ctx->CountDown == 0) { + return EOF; + } + + --(ctx->CountDown); + + r = gdImageGetPixel(im, ctx->curx, ctx->cury); + + BumpPixel(ctx); + + return r; +} + +/* public */ + +static void GIFEncode(gdIOCtxPtr fp, int GWidth, int GHeight, int GInterlace, int Background, int Transparent, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im) +{ + int B; + int RWidth, RHeight; + int LeftOfs, TopOfs; + int Resolution; + int ColorMapSize; + int InitCodeSize; + int i; + GifCtx ctx; + + memset(&ctx, 0, sizeof(ctx)); + + ctx.Interlace = GInterlace; + ctx.in_count = 1; + + ColorMapSize = 1 << BitsPerPixel; + + RWidth = ctx.Width = GWidth; + RHeight = ctx.Height = GHeight; + LeftOfs = TopOfs = 0; + + Resolution = BitsPerPixel; + + /* Calculate number of bits we are expecting */ + ctx.CountDown = (long)ctx.Width * (long)ctx.Height; + + /* Indicate which pass we are on (if interlace) */ + ctx.Pass = 0; + + /* The initial code size */ + if(BitsPerPixel <= 1) { + InitCodeSize = 2; + } else { + InitCodeSize = BitsPerPixel; + } + + /* Set up the current x and y position */ + ctx.curx = ctx.cury = 0; + + /* Write the Magic header */ + gdPutBuf(Transparent < 0 ? "GIF87a" : "GIF89a", 6, fp); + + /* Write out the screen width and height */ + gifPutWord(RWidth, fp); + gifPutWord(RHeight, fp); + + /* Indicate that there is a global colour map */ + /* Yes, there is a color map */ + B = 0x80; + + /* OR in the resolution */ + B |= (Resolution - 1) << 4; + + /* OR in the Bits per Pixel */ + B |= (BitsPerPixel - 1); + + /* Write it out */ + gdPutC(B, fp); + + /* Write out the Background colour */ + gdPutC(Background, fp); + + /* Byte of 0's (future expansion) */ + gdPutC(0, fp); + + /* Write out the Global Colour Map */ + for(i = 0; i < ColorMapSize; ++i) { + gdPutC(Red[i], fp); + gdPutC(Green[i], fp); + gdPutC(Blue[i], fp); + } + + /* Write out extension for transparent colour index, if necessary. */ + if(Transparent >= 0) { + gdPutC('!', fp); + gdPutC(0xf9, fp); + gdPutC(4, fp); + gdPutC(1, fp); + gdPutC(0, fp); + gdPutC(0, fp); + gdPutC((unsigned char) Transparent, fp); + gdPutC(0, fp); + } + + /* Write an Image separator */ + gdPutC(',', fp); + + /* Write the Image header */ + gifPutWord(LeftOfs, fp); + gifPutWord(TopOfs, fp); + gifPutWord(ctx.Width, fp); + gifPutWord(ctx.Height, fp); + + /* Write out whether or not the image is interlaced */ + if(ctx.Interlace) { + gdPutC(0x40, fp); + } else { + gdPutC(0x00, fp); + } + + /* Write out the initial code size */ + gdPutC(InitCodeSize, fp); + + /* Go and actually compress the data */ + compress(InitCodeSize + 1, fp, im, &ctx); + + /* Write out a Zero-length packet (to end the series) */ + gdPutC(0, fp); + + /* Write the GIF file terminator */ + gdPutC(';', fp); +} + +static void GIFAnimEncode(gdIOCtxPtr fp, int IWidth, int IHeight, int LeftOfs, int TopOfs, int GInterlace, int Transparent, int Delay, int Disposal, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im) +{ + int B; + int ColorMapSize; + int InitCodeSize; + int i; + GifCtx ctx; + + memset(&ctx, 0, sizeof(ctx)); + + ctx.Interlace = GInterlace; + ctx.in_count = 1; + + ColorMapSize = 1 << BitsPerPixel; + + if(LeftOfs < 0) { + LeftOfs = 0; + } + if(TopOfs < 0) { + TopOfs = 0; + } + if(Delay < 0) { + Delay = 100; + } + if(Disposal < 0) { + Disposal = 1; + } + + ctx.Width = IWidth; + ctx.Height = IHeight; + + /* Calculate number of bits we are expecting */ + ctx.CountDown = (long)ctx.Width * (long)ctx.Height; + + /* Indicate which pass we are on (if interlace) */ + ctx.Pass = 0; + + /* The initial code size */ + if(BitsPerPixel <= 1) { + InitCodeSize = 2; + } else { + InitCodeSize = BitsPerPixel; + } + + /* Set up the current x and y position */ + ctx.curx = ctx.cury = 0; + + /* Write out extension for image animation and looping */ + gdPutC('!', fp); + gdPutC(0xf9, fp); + gdPutC(4, fp); + gdPutC((Transparent >= 0 ? 1 : 0) | (Disposal << 2), fp); + gdPutC((unsigned char)(Delay & 255), fp); + gdPutC((unsigned char)((Delay >> 8) & 255), fp); + gdPutC((unsigned char) Transparent, fp); + gdPutC(0, fp); + + /* Write an Image separator */ + gdPutC(',', fp); + + /* Write out the Image header */ + gifPutWord(LeftOfs, fp); + gifPutWord(TopOfs, fp); + gifPutWord(ctx.Width, fp); + gifPutWord(ctx.Height, fp); + + /* Indicate that there is a local colour map */ + B = (Red && Green && Blue) ? 0x80 : 0; + + /* OR in the interlacing */ + B |= ctx.Interlace ? 0x40 : 0; + + /* OR in the Bits per Pixel */ + B |= (Red && Green && Blue) ? (BitsPerPixel - 1) : 0; + + /* Write it out */ + gdPutC(B, fp); + + /* Write out the Local Colour Map */ + if(Red && Green && Blue) { + for(i = 0; i < ColorMapSize; ++i) { + gdPutC(Red[i], fp); + gdPutC(Green[i], fp); + gdPutC(Blue[i], fp); + } + } + + /* Write out the initial code size */ + gdPutC(InitCodeSize, fp); + + /* Go and actually compress the data */ + compress(InitCodeSize + 1, fp, im, &ctx); + + /* Write out a Zero-length packet (to end the series) */ + gdPutC(0, fp); +} + +/*************************************************************************** + * + * GIFCOMPR.C - GIF Image compression routines + * + * Lempel-Ziv compression based on 'compress'. GIF modifications by + * David Rowley (mgardi@watdcsu.waterloo.edu) + * + ***************************************************************************/ + +/* General DEFINEs */ + +#define GIFBITS 12 + +#ifdef NO_UCHAR +typedef char char_type; +#else /* NO_UCHAR */ +typedef unsigned char char_type; +#endif /* NO_UCHAR */ + +/* + * + * GIF Image compression - modified 'compress' + * + * Based on: compress.c - File compression ala IEEE Computer, June 1984. + * + * By Authors: Spencer W. Thomas (decvax!harpo!utah-cs!utah-gr!thomas) + * Jim McKie (decvax!mcvax!jim) + * Steve Davies (decvax!vax135!petsd!peora!srd) + * Ken Turkowski (decvax!decwrl!turtlevax!ken) + * James A. Woods (decvax!ihnp4!ames!jaw) + * Joe Orost (decvax!vax135!petsd!joe) + * + */ +#include <ctype.h> + +#define ARGVAL() (*++(*argv) || (--argc && *++argv)) + +#ifdef COMPATIBLE /* But wrong! */ +# define MAXCODE(n_bits) ((code_int) 1 << (n_bits) - 1) +#else /* COMPATIBLE */ +# define MAXCODE(n_bits) (((code_int) 1 << (n_bits)) - 1) +#endif /* COMPATIBLE */ + +#define HashTabOf(i) ctx->htab[i] +#define CodeTabOf(i) ctx->codetab[i] + + +/* + * To save much memory, we overlay the table used by compress() with those + * used by decompress(). The tab_prefix table is the same size and type + * as the codetab. The tab_suffix table needs 2**GIFBITS characters. We + * get this from the beginning of htab. The output stack uses the rest + * of htab, and contains characters. There is plenty of room for any + * possible stack (stack used to be 8000 characters). + */ + +#define tab_prefixof(i) CodeTabOf(i) +#define tab_suffixof(i) ((char_type*)(htab))[i] +#define de_stack ((char_type*)&tab_suffixof((code_int)1 << GIFBITS)) + +/* + * compress stdin to stdout + * + * Algorithm: use open addressing double hashing (no chaining) on the + * prefix code / next character combination. We do a variant of Knuth's + * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime + * secondary probe. Here, the modular division first probe is gives way + * to a faster exclusive-or manipulation. Also do block compression with + * an adaptive reset, whereby the code table is cleared when the compression + * ratio decreases, but after the table fills. The variable-length output + * codes are re-sized at this point, and a special CLEAR code is generated + * for the decompressor. Late addition: construct the table according to + * file size for noticeable speed improvement on small files. Please direct + * questions about this implementation to ames!jaw. + */ + +static void output(code_int code, GifCtx *ctx); + +static void compress(int init_bits, gdIOCtxPtr outfile, gdImagePtr im, GifCtx *ctx) +{ + register long fcode; + register code_int i; + register int c; + register code_int ent; + register code_int disp; + register code_int hsize_reg; + register int hshift; + + /* Set up the globals: + * g_init_bits - initial number of bits + * g_outfile - pointer to output file */ + ctx->g_init_bits = init_bits; + ctx->g_outfile = outfile; + + /* Set up the necessary values */ + ctx->offset = 0; + ctx->out_count = 0; + ctx->clear_flg = 0; + ctx->in_count = 1; + ctx->maxcode = MAXCODE(ctx->n_bits = ctx->g_init_bits); + + ctx->ClearCode = (1 << (init_bits - 1)); + ctx->EOFCode = ctx->ClearCode + 1; + ctx->free_ent = ctx->ClearCode + 2; + + char_init(ctx); + + ent = GIFNextPixel(im, ctx); + + hshift = 0; + for(fcode = (long)hsize; fcode < 65536L; fcode *= 2L) { + ++hshift; + } + hshift = 8 - hshift; /* set hash code range bound */ + + hsize_reg = hsize; + cl_hash((count_int) hsize_reg, ctx); /* clear hash table */ + + output((code_int)ctx->ClearCode, ctx); + +#ifdef SIGNED_COMPARE_SLOW + while((c = GIFNextPixel(im)) != (unsigned) EOF) { +#else /* SIGNED_COMPARE_SLOW */ + while((c = GIFNextPixel(im, ctx)) != EOF) { +#endif /* SIGNED_COMPARE_SLOW */ + + ++(ctx->in_count); + + fcode = (long) (((long) c << maxbits) + ent); + i = (((code_int)c << hshift) ^ ent); /* xor hashing */ + + if(HashTabOf(i) == fcode) { + ent = CodeTabOf (i); + continue; + } else if ((long)HashTabOf (i) < 0) {/* empty slot */ + goto nomatch; + } + + disp = hsize_reg - i; /* secondary hash (after G. Knott) */ + + if(i == 0) { + disp = 1; + } + +probe: + if((i -= disp) < 0) { + i += hsize_reg; + } + + if(HashTabOf(i) == fcode) { + ent = CodeTabOf (i); + continue; + } + + if((long)HashTabOf(i) > 0) { + goto probe; + } + +nomatch: + output((code_int) ent, ctx); + ++(ctx->out_count); + ent = c; +#ifdef SIGNED_COMPARE_SLOW + if((unsigned) ctx->free_ent < (unsigned) maxmaxcode) { +#else /*SIGNED_COMPARE_SLOW*/ + if (ctx->free_ent < maxmaxcode) { /* } */ +#endif /*SIGNED_COMPARE_SLOW*/ + CodeTabOf(i) = ctx->free_ent++; /* code -> hashtable */ + HashTabOf(i) = fcode; + } else { + cl_block(ctx); + } + } + + /* Put out the final code. */ + output((code_int)ent, ctx); + ++(ctx->out_count); + output((code_int) ctx->EOFCode, ctx); +} + +/***************************************************************** + * TAG( output ) + * + * Output the given code. + * Inputs: + * code: A n_bits-bit integer. If == -1, then EOF. This assumes + * that n_bits =< (long)wordsize - 1. + * Outputs: + * Outputs code to the file. + * Assumptions: + * Chars are 8 bits long. + * Algorithm: + * Maintain a GIFBITS character long buffer (so that 8 codes will + * fit in it exactly). Use the VAX insv instruction to insert each + * code in turn. When the buffer fills up empty it and start over. + */ + +static unsigned long masks[] = { + 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, + 0x001F, 0x003F, 0x007F, 0x00FF, + 0x01FF, 0x03FF, 0x07FF, 0x0FFF, + 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF +}; + +static void output(code_int code, GifCtx *ctx) +{ + ctx->cur_accum &= masks[ctx->cur_bits]; + + if(ctx->cur_bits > 0) { + ctx->cur_accum |= ((long)code << ctx->cur_bits); + } else { + ctx->cur_accum = code; + } + + ctx->cur_bits += ctx->n_bits; + + while(ctx->cur_bits >= 8) { + char_out((unsigned int)(ctx->cur_accum & 0xff), ctx); + ctx->cur_accum >>= 8; + ctx->cur_bits -= 8; + } + + /* + * If the next entry is going to be too big for the code size, + * then increase it, if possible. + */ + if(ctx->free_ent > ctx->maxcode || ctx->clear_flg) { + if(ctx->clear_flg) { + ctx->maxcode = MAXCODE (ctx->n_bits = ctx->g_init_bits); + ctx->clear_flg = 0; + } else { + ++(ctx->n_bits); + if(ctx->n_bits == maxbits) { + ctx->maxcode = maxmaxcode; + } else { + ctx->maxcode = MAXCODE(ctx->n_bits); + } + } + } + + if(code == ctx->EOFCode) { + /* At EOF, write the rest of the buffer. */ + while(ctx->cur_bits > 0) { + char_out((unsigned int)(ctx->cur_accum & 0xff), ctx); + ctx->cur_accum >>= 8; + ctx->cur_bits -= 8; + } + + flush_char(ctx); + } +} + +/* + * Clear out the hash table + */ +static void cl_block (GifCtx *ctx) /* table clear for block compress */ +{ + cl_hash((count_int) hsize, ctx); + ctx->free_ent = ctx->ClearCode + 2; + ctx->clear_flg = 1; + + output((code_int)ctx->ClearCode, ctx); +} + +static void cl_hash(register count_int chsize, GifCtx *ctx) /* reset code table */ +{ + register count_int *htab_p = ctx->htab+chsize; + register long i; + register long m1 = -1; + + i = chsize - 16; + do { /* might use Sys V memset(3) here */ + *(htab_p - 16) = m1; + *(htab_p - 15) = m1; + *(htab_p - 14) = m1; + *(htab_p - 13) = m1; + *(htab_p - 12) = m1; + *(htab_p - 11) = m1; + *(htab_p - 10) = m1; + *(htab_p - 9) = m1; + *(htab_p - 8) = m1; + *(htab_p - 7) = m1; + *(htab_p - 6) = m1; + *(htab_p - 5) = m1; + *(htab_p - 4) = m1; + *(htab_p - 3) = m1; + *(htab_p - 2) = m1; + *(htab_p - 1) = m1; + htab_p -= 16; + } while((i -= 16) >= 0); + + for(i += 16; i > 0; --i) { + *--htab_p = m1; + } +} + +/****************************************************************************** + * + * GIF Specific routines + * + ******************************************************************************/ + +/* + * Set up the 'byte output' routine + */ +static void char_init(GifCtx *ctx) +{ + ctx->a_count = 0; +} + +/* + * Add a character to the end of the current packet, and if it is 254 + * characters, flush the packet to disk. + */ +static void char_out(int c, GifCtx *ctx) +{ + ctx->accum[ctx->a_count++] = c; + if(ctx->a_count >= 254) { + flush_char(ctx); + } +} + +/* + * Flush the packet to disk, and reset the accumulator + */ +static void flush_char(GifCtx *ctx) +{ + if(ctx->a_count > 0) { + gdPutC(ctx->a_count, ctx->g_outfile); + gdPutBuf(ctx->accum, ctx->a_count, ctx->g_outfile); + ctx->a_count = 0; + } +} + +static int gifPutWord(int w, gdIOCtx *out) +{ + /* Byte order is little-endian */ + gdPutC(w & 0xFF, out); + gdPutC((w >> 8) & 0xFF, out); + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_intern.h b/Build/source/libs/gd/libgd-2.1.1/src/gd_intern.h new file mode 100644 index 00000000000..a30062b11f8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_intern.h @@ -0,0 +1,90 @@ +#ifndef GD_INTERN_H +#define GD_INTERN_H + +#if HAVE_LIMITS_H +#include <limits.h> +#endif + + +#ifndef MAXPATHLEN +# ifdef PATH_MAX +# define MAXPATHLEN PATH_MAX +# elif defined(MAX_PATH) +# define MAXPATHLEN MAX_PATH +# else +# if defined(__GNU__) +# define MAXPATHLEN 4096 +# else +# define MAXPATHLEN 256 /* Should be safe for any weird systems that do not define it */ +# endif +# endif +#endif + +#ifdef HAVE_STDINT_H +# include <stdint.h> +#else +# if defined(HAVE_INTTYPES_H) +# include <inttypes.h> +# else +# include "msinttypes/inttypes.h" +# endif +#endif + +#include "gd.h" + +#ifndef MIN +#define MIN(a,b) ((a)<(b)?(a):(b)) +#endif +#define MIN3(a,b,c) ((a)<(b)?(MIN(a,c)):(MIN(b,c))) +#ifndef MAX +#define MAX(a,b) ((a)<(b)?(b):(a)) +#endif +#define MAX3(a,b,c) ((a)<(b)?(MAX(b,c)):(MAX(a,c))) + + +typedef enum { + HORIZONTAL, + VERTICAL, +} gdAxis; + +/* Convert a double to an unsigned char, rounding to the nearest + * integer and clamping the result between 0 and max. The absolute + * value of clr must be less than the maximum value of an unsigned + * short. */ +static inline unsigned char +uchar_clamp(double clr, unsigned char max) { + unsigned short result; + + //assert(fabs(clr) <= SHRT_MAX); + + /* Casting a negative float to an unsigned short is undefined. + * However, casting a float to a signed truncates toward zero and + * casting a negative signed value to an unsigned of the same size + * results in a bit-identical value (assuming twos-complement + * arithmetic). This is what we want: all legal negative values + * for clr will be greater than 255. */ + + /* Convert and clamp. */ + result = (unsigned short)(short)(clr + 0.5); + if (result > max) { + result = (clr < 0) ? 0 : max; + }/* if */ + + return result; +}/* uchar_clamp*/ + + +/* Internal prototypes: */ + +/* gd_rotate.c */ +gdImagePtr gdImageRotate90(gdImagePtr src, int ignoretransparent); +gdImagePtr gdImageRotate180(gdImagePtr src, int ignoretransparent); +gdImagePtr gdImageRotate270(gdImagePtr src, int ignoretransparent); + + + + + + +#endif + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_interpolation.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_interpolation.c new file mode 100644 index 00000000000..a829d4f2d9e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_interpolation.c @@ -0,0 +1,2605 @@ +/* + * The two pass scaling function is based on: + * Filtered Image Rescaling + * Based on Gems III + * - Schumacher general filtered image rescaling + * (pp. 414-424) + * by Dale Schumacher + * + * Additional changes by Ray Gardener, Daylon Graphics Ltd. + * December 4, 1999 + * + * Ported to libgd by Pierre Joye. Support for multiple channels + * added (argb for now). + * + * Initial sources code is avaibable in the Gems Source Code Packages: + * http://www.acm.org/pubs/tog/GraphicsGems/GGemsIII.tar.gz + * + */ + +/* + Summary: + + - Horizontal filter contributions are calculated on the fly, + as each column is mapped from src to dst image. This lets + us omit having to allocate a temporary full horizontal stretch + of the src image. + + - If none of the src pixels within a sampling region differ, + then the output pixel is forced to equal (any of) the source pixel. + This ensures that filters do not corrupt areas of constant color. + + - Filter weight contribution results, after summing, are + rounded to the nearest pixel color value instead of + being casted to ILubyte (usually an int or char). Otherwise, + artifacting occurs. + +*/ + +/* + Additional functions are available for simple rotation or up/downscaling. + downscaling using the fixed point implementations are usually much faster + than the existing gdImageCopyResampled while having a similar or better + quality. + + For image rotations, the optimized versions have a lazy antialiasing for + the edges of the images. For a much better antialiased result, the affine + function is recommended. +*/ + +/* +TODO: + - Optimize pixel accesses and loops once we have continuous buffer + - Add scale support for a portion only of an image (equivalent of copyresized/resampled) + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif /* HAVE_CONFIG_H */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <math.h> +#include <assert.h> + +#define NDEBUG 1 /* TODO: disable/enable assertions in configure. */ +#include <assert.h> + +#include "gd.h" +#include "gdhelpers.h" +#include "gd_intern.h" + +#ifdef _MSC_VER +# pragma optimize("t", on) +# include <emmintrin.h> +#endif + +static gdImagePtr gdImageScaleBilinear(gdImagePtr im, + const unsigned int new_width, + const unsigned int new_height); +static gdImagePtr gdImageScaleBicubicFixed(gdImagePtr src, + const unsigned int width, + const unsigned int height); +static gdImagePtr gdImageScaleNearestNeighbour(gdImagePtr im, + const unsigned int width, + const unsigned int height); +static gdImagePtr gdImageRotateNearestNeighbour(gdImagePtr src, + const float degrees, + const int bgColor); +static gdImagePtr gdImageRotateBilinear(gdImagePtr src, const float degrees, + const int bgColor); +static gdImagePtr gdImageRotateBicubicFixed(gdImagePtr src, const float degrees, + const int bgColor); +static gdImagePtr gdImageRotateGeneric(gdImagePtr src, const float degrees, + const int bgColor); + + +#define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x))) + +/* only used here, let do a generic fixed point integers later if required by other + part of GD */ +typedef long gdFixed; +/* Integer to fixed point */ +#define gd_itofx(x) ((x) << 8) + +/* Float to fixed point */ +#define gd_ftofx(x) (long)((x) * 256) + +/* Double to fixed point */ +#define gd_dtofx(x) (long)((x) * 256) + +/* Fixed point to integer */ +#define gd_fxtoi(x) ((x) >> 8) + +/* Fixed point to float */ +# define gd_fxtof(x) ((float)(x) / 256) + +/* Fixed point to double */ +#define gd_fxtod(x) ((double)(x) / 256) + +/* Multiply a fixed by a fixed */ +#define gd_mulfx(x,y) (((x) * (y)) >> 8) + +/* Divide a fixed by a fixed */ +#define gd_divfx(x,y) (((x) << 8) / (y)) + +typedef struct +{ + double *Weights; /* Normalized weights of neighboring pixels */ + int Left,Right; /* Bounds of source pixels window */ +} ContributionType; /* Contirbution information for a single pixel */ + +typedef struct +{ + ContributionType *ContribRow; /* Row (or column) of contribution weights */ + unsigned int WindowSize, /* Filter window size (of affecting source pixels) */ + LineLength; /* Length of line (no. or rows / cols) */ +} LineContribType; + +/* Each core filter has its own radius */ +#define DEFAULT_FILTER_BICUBIC 3.0 +#define DEFAULT_FILTER_BOX 0.5 +#define DEFAULT_FILTER_GENERALIZED_CUBIC 0.5 +#define DEFAULT_FILTER_RADIUS 1.0 +#define DEFAULT_LANCZOS8_RADIUS 8.0 +#define DEFAULT_LANCZOS3_RADIUS 3.0 +#define DEFAULT_HERMITE_RADIUS 1.0 +#define DEFAULT_BOX_RADIUS 0.5 +#define DEFAULT_TRIANGLE_RADIUS 1.0 +#define DEFAULT_BELL_RADIUS 1.5 +#define DEFAULT_CUBICSPLINE_RADIUS 2.0 +#define DEFAULT_MITCHELL_RADIUS 2.0 +#define DEFAULT_COSINE_RADIUS 1.0 +#define DEFAULT_CATMULLROM_RADIUS 2.0 +#define DEFAULT_QUADRATIC_RADIUS 1.5 +#define DEFAULT_QUADRATICBSPLINE_RADIUS 1.5 +#define DEFAULT_CUBICCONVOLUTION_RADIUS 3.0 +#define DEFAULT_GAUSSIAN_RADIUS 1.0 +#define DEFAULT_HANNING_RADIUS 1.0 +#define DEFAULT_HAMMING_RADIUS 1.0 +#define DEFAULT_SINC_RADIUS 1.0 +#define DEFAULT_WELSH_RADIUS 1.0 + +static double KernelBessel_J1(const double x) +{ + double p, q; + + register long i; + + static const double + Pone[] = + { + 0.581199354001606143928050809e+21, + -0.6672106568924916298020941484e+20, + 0.2316433580634002297931815435e+19, + -0.3588817569910106050743641413e+17, + 0.2908795263834775409737601689e+15, + -0.1322983480332126453125473247e+13, + 0.3413234182301700539091292655e+10, + -0.4695753530642995859767162166e+7, + 0.270112271089232341485679099e+4 + }, + Qone[] = + { + 0.11623987080032122878585294e+22, + 0.1185770712190320999837113348e+20, + 0.6092061398917521746105196863e+17, + 0.2081661221307607351240184229e+15, + 0.5243710262167649715406728642e+12, + 0.1013863514358673989967045588e+10, + 0.1501793594998585505921097578e+7, + 0.1606931573481487801970916749e+4, + 0.1e+1 + }; + + p = Pone[8]; + q = Qone[8]; + for (i=7; i >= 0; i--) + { + p = p*x*x+Pone[i]; + q = q*x*x+Qone[i]; + } + return (double)(p/q); +} + +static double KernelBessel_P1(const double x) +{ + double p, q; + + register long i; + + static const double + Pone[] = + { + 0.352246649133679798341724373e+5, + 0.62758845247161281269005675e+5, + 0.313539631109159574238669888e+5, + 0.49854832060594338434500455e+4, + 0.2111529182853962382105718e+3, + 0.12571716929145341558495e+1 + }, + Qone[] = + { + 0.352246649133679798068390431e+5, + 0.626943469593560511888833731e+5, + 0.312404063819041039923015703e+5, + 0.4930396490181088979386097e+4, + 0.2030775189134759322293574e+3, + 0.1e+1 + }; + + p = Pone[5]; + q = Qone[5]; + for (i=4; i >= 0; i--) + { + p = p*(8.0/x)*(8.0/x)+Pone[i]; + q = q*(8.0/x)*(8.0/x)+Qone[i]; + } + return (double)(p/q); +} + +static double KernelBessel_Q1(const double x) +{ + double p, q; + + register long i; + + static const double + Pone[] = + { + 0.3511751914303552822533318e+3, + 0.7210391804904475039280863e+3, + 0.4259873011654442389886993e+3, + 0.831898957673850827325226e+2, + 0.45681716295512267064405e+1, + 0.3532840052740123642735e-1 + }, + Qone[] = + { + 0.74917374171809127714519505e+4, + 0.154141773392650970499848051e+5, + 0.91522317015169922705904727e+4, + 0.18111867005523513506724158e+4, + 0.1038187585462133728776636e+3, + 0.1e+1 + }; + + p = Pone[5]; + q = Qone[5]; + for (i=4; i >= 0; i--) + { + p = p*(8.0/x)*(8.0/x)+Pone[i]; + q = q*(8.0/x)*(8.0/x)+Qone[i]; + } + return (double)(p/q); +} + +static double KernelBessel_Order1(double x) +{ + double p, q; + + if (x == 0.0) + return (0.0f); + p = x; + if (x < 0.0) + x=(-x); + if (x < 8.0) + return (p*KernelBessel_J1(x)); + q = (double)sqrt(2.0f/(M_PI*x))*(double)(KernelBessel_P1(x)*(1.0f/sqrt(2.0f)*(sin(x)-cos(x)))-8.0f/x*KernelBessel_Q1(x)* + (-1.0f/sqrt(2.0f)*(sin(x)+cos(x)))); + if (p < 0.0f) + q = (-q); + return (q); +} + +static double filter_bessel(const double x) +{ + if (x == 0.0f) + return (double)(M_PI/4.0f); + return (KernelBessel_Order1((double)M_PI*x)/(2.0f*x)); +} + + +static double filter_blackman(const double x) +{ + return (0.42f+0.5f*(double)cos(M_PI*x)+0.08f*(double)cos(2.0f*M_PI*x)); +} + +/** + * Bicubic interpolation kernel (a=-1): + \verbatim + / + | 1-2|t|**2+|t|**3 , if |t| < 1 + h(t) = | 4-8|t|+5|t|**2-|t|**3 , if 1<=|t|<2 + | 0 , otherwise + \ + \endverbatim + * ***bd*** 2.2004 + */ +static double filter_bicubic(const double t) +{ + const double abs_t = (double)fabs(t); + const double abs_t_sq = abs_t * abs_t; + if (abs_t<1) return 1-2*abs_t_sq+abs_t_sq*abs_t; + if (abs_t<2) return 4 - 8*abs_t +5*abs_t_sq - abs_t_sq*abs_t; + return 0; +} + +/** + * Generalized cubic kernel (for a=-1 it is the same as BicubicKernel): + \verbatim + / + | (a+2)|t|**3 - (a+3)|t|**2 + 1 , |t| <= 1 + h(t) = | a|t|**3 - 5a|t|**2 + 8a|t| - 4a , 1 < |t| <= 2 + | 0 , otherwise + \ + \endverbatim + * Often used values for a are -1 and -1/2. + */ +static double filter_generalized_cubic(const double t) +{ + const double a = -DEFAULT_FILTER_GENERALIZED_CUBIC; + double abs_t = (double)fabs(t); + double abs_t_sq = abs_t * abs_t; + if (abs_t < 1) return (a + 2) * abs_t_sq * abs_t - (a + 3) * abs_t_sq + 1; + if (abs_t < 2) return a * abs_t_sq * abs_t - 5 * a * abs_t_sq + 8 * a * abs_t - 4 * a; + return 0; +} + +#ifdef FUNCTION_NOT_USED_YET +/* CubicSpline filter, default radius 2 */ +static double filter_cubic_spline(const double x1) +{ + const double x = x1 < 0.0 ? -x1 : x1; + + if (x < 1.0 ) { + const double x2 = x*x; + + return (0.5 * x2 * x - x2 + 2.0 / 3.0); + } + if (x < 2.0) { + return (pow(2.0 - x, 3.0)/6.0); + } + return 0; +} +#endif + +#ifdef FUNCTION_NOT_USED_YET +/* CubicConvolution filter, default radius 3 */ +static double filter_cubic_convolution(const double x1) +{ + const double x = x1 < 0.0 ? -x1 : x1; + const double x2 = x1 * x1; + const double x2_x = x2 * x; + + if (x <= 1.0) return ((4.0 / 3.0)* x2_x - (7.0 / 3.0) * x2 + 1.0); + if (x <= 2.0) return (- (7.0 / 12.0) * x2_x + 3 * x2 - (59.0 / 12.0) * x + 2.5); + if (x <= 3.0) return ( (1.0/12.0) * x2_x - (2.0 / 3.0) * x2 + 1.75 * x - 1.5); + return 0; +} +#endif + +static double filter_box(double x) { + if (x < - DEFAULT_FILTER_BOX) + return 0.0f; + if (x < DEFAULT_FILTER_BOX) + return 1.0f; + return 0.0f; +} + +static double filter_catmullrom(const double x) +{ + if (x < -2.0) + return(0.0f); + if (x < -1.0) + return(0.5f*(4.0f+x*(8.0f+x*(5.0f+x)))); + if (x < 0.0) + return(0.5f*(2.0f+x*x*(-5.0f-3.0f*x))); + if (x < 1.0) + return(0.5f*(2.0f+x*x*(-5.0f+3.0f*x))); + if (x < 2.0) + return(0.5f*(4.0f+x*(-8.0f+x*(5.0f-x)))); + return(0.0f); +} + +#ifdef FUNCTION_NOT_USED_YET +static double filter_filter(double t) +{ + /* f(t) = 2|t|^3 - 3|t|^2 + 1, -1 <= t <= 1 */ + if(t < 0.0) t = -t; + if(t < 1.0) return((2.0 * t - 3.0) * t * t + 1.0); + return(0.0); +} +#endif + +#ifdef FUNCTION_NOT_USED_YET +/* Lanczos8 filter, default radius 8 */ +static double filter_lanczos8(const double x1) +{ + const double x = x1 < 0.0 ? -x1 : x1; +#define R DEFAULT_LANCZOS8_RADIUS + + if ( x == 0.0) return 1; + + if ( x < R) { + return R * sin(x*M_PI) * sin(x * M_PI/ R) / (x * M_PI * x * M_PI); + } + return 0.0; +#undef R +} +#endif + +#ifdef FUNCTION_NOT_USED_YET +/* Lanczos3 filter, default radius 3 */ +static double filter_lanczos3(const double x1) +{ + const double x = x1 < 0.0 ? -x1 : x1; +#define R DEFAULT_LANCZOS3_RADIUS + + if ( x == 0.0) return 1; + + if ( x < R) + { + return R * sin(x*M_PI) * sin(x * M_PI / R) / (x * M_PI * x * M_PI); + } + return 0.0; +#undef R +} +#endif + +/* Hermite filter, default radius 1 */ +static double filter_hermite(const double x1) +{ + const double x = x1 < 0.0 ? -x1 : x1; + + if (x < 1.0) return ((2.0 * x - 3) * x * x + 1.0 ); + + return 0.0; +} + +/* Trangle filter, default radius 1 */ +static double filter_triangle(const double x1) +{ + const double x = x1 < 0.0 ? -x1 : x1; + if (x < 1.0) return (1.0 - x); + return 0.0; +} + +/* Bell filter, default radius 1.5 */ +static double filter_bell(const double x1) +{ + const double x = x1 < 0.0 ? -x1 : x1; + + if (x < 0.5) return (0.75 - x*x); + if (x < 1.5) return (0.5 * pow(x - 1.5, 2.0)); + return 0.0; +} + +/* Mitchell filter, default radius 2.0 */ +static double filter_mitchell(const double x) +{ +#define KM_B (1.0f/3.0f) +#define KM_C (1.0f/3.0f) +#define KM_P0 (( 6.0f - 2.0f * KM_B ) / 6.0f) +#define KM_P2 ((-18.0f + 12.0f * KM_B + 6.0f * KM_C) / 6.0f) +#define KM_P3 (( 12.0f - 9.0f * KM_B - 6.0f * KM_C) / 6.0f) +#define KM_Q0 (( 8.0f * KM_B + 24.0f * KM_C) / 6.0f) +#define KM_Q1 ((-12.0f * KM_B - 48.0f * KM_C) / 6.0f) +#define KM_Q2 (( 6.0f * KM_B + 30.0f * KM_C) / 6.0f) +#define KM_Q3 (( -1.0f * KM_B - 6.0f * KM_C) / 6.0f) + + if (x < -2.0) + return(0.0f); + if (x < -1.0) + return(KM_Q0-x*(KM_Q1-x*(KM_Q2-x*KM_Q3))); + if (x < 0.0f) + return(KM_P0+x*x*(KM_P2-x*KM_P3)); + if (x < 1.0f) + return(KM_P0+x*x*(KM_P2+x*KM_P3)); + if (x < 2.0f) + return(KM_Q0+x*(KM_Q1+x*(KM_Q2+x*KM_Q3))); + return(0.0f); +} + + + +#ifdef FUNCTION_NOT_USED_YET +/* Cosine filter, default radius 1 */ +static double filter_cosine(const double x) +{ + if ((x >= -1.0) && (x <= 1.0)) return ((cos(x * M_PI) + 1.0)/2.0); + + return 0; +} +#endif + +/* Quadratic filter, default radius 1.5 */ +static double filter_quadratic(const double x1) +{ + const double x = x1 < 0.0 ? -x1 : x1; + + if (x <= 0.5) return (- 2.0 * x * x + 1); + if (x <= 1.5) return (x * x - 2.5* x + 1.5); + return 0.0; +} + +static double filter_bspline(const double x) +{ + if (x>2.0f) { + return 0.0f; + } else { + double a, b, c, d; + /* Was calculated anyway cause the "if((x-1.0f) < 0)" */ + const double xm1 = x - 1.0f; + const double xp1 = x + 1.0f; + const double xp2 = x + 2.0f; + + if ((xp2) <= 0.0f) a = 0.0f; else a = xp2*xp2*xp2; + if ((xp1) <= 0.0f) b = 0.0f; else b = xp1*xp1*xp1; + if (x <= 0) c = 0.0f; else c = x*x*x; + if ((xm1) <= 0.0f) d = 0.0f; else d = xm1*xm1*xm1; + + return (0.16666666666666666667f * (a - (4.0f * b) + (6.0f * c) - (4.0f * d))); + } +} + +#ifdef FUNCTION_NOT_USED_YET +/* QuadraticBSpline filter, default radius 1.5 */ +static double filter_quadratic_bspline(const double x1) +{ + const double x = x1 < 0.0 ? -x1 : x1; + + if (x <= 0.5) return (- x * x + 0.75); + if (x <= 1.5) return (0.5 * x * x - 1.5 * x + 1.125); + return 0.0; +} +#endif + +static double filter_gaussian(const double x) +{ + /* return(exp((double) (-2.0 * x * x)) * sqrt(2.0 / M_PI)); */ + return (double)(exp(-2.0f * x * x) * 0.79788456080287f); +} + +static double filter_hanning(const double x) +{ + /* A Cosine windowing function */ + return(0.5 + 0.5 * cos(M_PI * x)); +} + +static double filter_hamming(const double x) +{ + /* should be + (0.54+0.46*cos(M_PI*(double) x)); + but this approximation is sufficient */ + if (x < -1.0f) + return 0.0f; + if (x < 0.0f) + return 0.92f*(-2.0f*x-3.0f)*x*x+1.0f; + if (x < 1.0f) + return 0.92f*(2.0f*x-3.0f)*x*x+1.0f; + return 0.0f; +} + +static double filter_power(const double x) +{ + const double a = 2.0f; + if (fabs(x)>1) return 0.0f; + return (1.0f - (double)fabs(pow(x,a))); +} + +static double filter_sinc(const double x) +{ + /* X-scaled Sinc(x) function. */ + if (x == 0.0) return(1.0); + return (sin(M_PI * (double) x) / (M_PI * (double) x)); +} + +#ifdef FUNCTION_NOT_USED_YET +static double filter_welsh(const double x) +{ + /* Welsh parabolic windowing filter */ + if (x < 1.0) + return(1 - x*x); + return(0.0); +} +#endif + +#if defined(_MSC_VER) && !defined(inline) +# define inline __inline +#endif + +/* Copied from upstream's libgd */ +static inline int _color_blend (const int dst, const int src) +{ + const int src_alpha = gdTrueColorGetAlpha(src); + + if( src_alpha == gdAlphaOpaque ) { + return src; + } else { + const int dst_alpha = gdTrueColorGetAlpha(dst); + + if( src_alpha == gdAlphaTransparent ) return dst; + if( dst_alpha == gdAlphaTransparent ) { + return src; + } else { + register int alpha, red, green, blue; + const int src_weight = gdAlphaTransparent - src_alpha; + const int dst_weight = (gdAlphaTransparent - dst_alpha) * src_alpha / gdAlphaMax; + const int tot_weight = src_weight + dst_weight; + + alpha = src_alpha * dst_alpha / gdAlphaMax; + + red = (gdTrueColorGetRed(src) * src_weight + + gdTrueColorGetRed(dst) * dst_weight) / tot_weight; + green = (gdTrueColorGetGreen(src) * src_weight + + gdTrueColorGetGreen(dst) * dst_weight) / tot_weight; + blue = (gdTrueColorGetBlue(src) * src_weight + + gdTrueColorGetBlue(dst) * dst_weight) / tot_weight; + + return ((alpha << 24) + (red << 16) + (green << 8) + blue); + } + } +} + +static inline int _setEdgePixel(const gdImagePtr src, unsigned int x, unsigned int y, gdFixed coverage, const int bgColor) +{ + const gdFixed f_127 = gd_itofx(127); + register int c = src->tpixels[y][x]; + c = c | (( (int) (gd_fxtof(gd_mulfx(coverage, f_127)) + 50.5f)) << 24); + return _color_blend(bgColor, c); +} + +static inline int getPixelOverflowTC(gdImagePtr im, const int x, const int y, const int bgColor) +{ + if (gdImageBoundsSafe(im, x, y)) { + const int c = im->tpixels[y][x]; + if (c == im->transparent) { + return bgColor == -1 ? gdTrueColorAlpha(0, 0, 0, 127) : bgColor; + } + return c; + } else { + register int border = 0; + + if (y < im->cy1) { + border = im->tpixels[0][im->cx1]; + goto processborder; + } + + if (y < im->cy1) { + border = im->tpixels[0][im->cx1]; + goto processborder; + } + + if (y > im->cy2) { + if (x >= im->cx1 && x <= im->cx1) { + border = im->tpixels[im->cy2][x]; + goto processborder; + } else { + return gdTrueColorAlpha(0, 0, 0, 127); + } + } + + /* y is bound safe at this point */ + if (x < im->cx1) { + border = im->tpixels[y][im->cx1]; + goto processborder; + } + + if (x > im->cx2) { + border = im->tpixels[y][im->cx2]; + } + +processborder: + if (border == im->transparent) { + return gdTrueColorAlpha(0, 0, 0, 127); + } else{ + return gdTrueColorAlpha(gdTrueColorGetRed(border), gdTrueColorGetGreen(border), gdTrueColorGetBlue(border), 127); + } + } +} + +#define colorIndex2RGBA(c) gdTrueColorAlpha(im->red[(c)], im->green[(c)], im->blue[(c)], im->alpha[(c)]) +#define colorIndex2RGBcustomA(c, a) gdTrueColorAlpha(im->red[(c)], im->green[(c)], im->blue[(c)], im->alpha[(a)]) +static inline int getPixelOverflowPalette(gdImagePtr im, const int x, const int y, const int bgColor) +{ + if (gdImageBoundsSafe(im, x, y)) { + const int c = im->pixels[y][x]; + if (c == im->transparent) { + return bgColor == -1 ? gdTrueColorAlpha(0, 0, 0, 127) : bgColor; + } + return colorIndex2RGBA(c); + } else { + register int border = 0; + if (y < im->cy1) { + border = gdImageGetPixel(im, im->cx1, 0); + goto processborder; + } + + if (y < im->cy1) { + border = gdImageGetPixel(im, im->cx1, 0); + goto processborder; + } + + if (y > im->cy2) { + if (x >= im->cx1 && x <= im->cx1) { + border = gdImageGetPixel(im, x, im->cy2); + goto processborder; + } else { + return gdTrueColorAlpha(0, 0, 0, 127); + } + } + + /* y is bound safe at this point */ + if (x < im->cx1) { + border = gdImageGetPixel(im, im->cx1, y); + goto processborder; + } + + if (x > im->cx2) { + border = gdImageGetPixel(im, im->cx2, y); + } + +processborder: + if (border == im->transparent) { + return gdTrueColorAlpha(0, 0, 0, 127); + } else{ + return colorIndex2RGBcustomA(border, 127); + } + } +} + +static int getPixelInterpolateWeight(gdImagePtr im, const double x, const double y, const int bgColor) +{ + /* Closest pixel <= (xf,yf) */ + int sx = (int)(x); + int sy = (int)(y); + const double xf = x - (double)sx; + const double yf = y - (double)sy; + const double nxf = (double) 1.0 - xf; + const double nyf = (double) 1.0 - yf; + const double m1 = xf * yf; + const double m2 = nxf * yf; + const double m3 = xf * nyf; + const double m4 = nxf * nyf; + + /* get color values of neighbouring pixels */ + const int c1 = im->trueColor == 1 ? getPixelOverflowTC(im, sx, sy, bgColor) : getPixelOverflowPalette(im, sx, sy, bgColor); + const int c2 = im->trueColor == 1 ? getPixelOverflowTC(im, sx - 1, sy, bgColor) : getPixelOverflowPalette(im, sx - 1, sy, bgColor); + const int c3 = im->trueColor == 1 ? getPixelOverflowTC(im, sx, sy - 1, bgColor) : getPixelOverflowPalette(im, sx, sy - 1, bgColor); + const int c4 = im->trueColor == 1 ? getPixelOverflowTC(im, sx - 1, sy - 1, bgColor) : getPixelOverflowPalette(im, sx, sy - 1, bgColor); + int r, g, b, a; + + if (x < 0) sx--; + if (y < 0) sy--; + + /* component-wise summing-up of color values */ + if (im->trueColor) { + r = (int)(m1*gdTrueColorGetRed(c1) + m2*gdTrueColorGetRed(c2) + m3*gdTrueColorGetRed(c3) + m4*gdTrueColorGetRed(c4)); + g = (int)(m1*gdTrueColorGetGreen(c1) + m2*gdTrueColorGetGreen(c2) + m3*gdTrueColorGetGreen(c3) + m4*gdTrueColorGetGreen(c4)); + b = (int)(m1*gdTrueColorGetBlue(c1) + m2*gdTrueColorGetBlue(c2) + m3*gdTrueColorGetBlue(c3) + m4*gdTrueColorGetBlue(c4)); + a = (int)(m1*gdTrueColorGetAlpha(c1) + m2*gdTrueColorGetAlpha(c2) + m3*gdTrueColorGetAlpha(c3) + m4*gdTrueColorGetAlpha(c4)); + } else { + r = (int)(m1*im->red[(c1)] + m2*im->red[(c2)] + m3*im->red[(c3)] + m4*im->red[(c4)]); + g = (int)(m1*im->green[(c1)] + m2*im->green[(c2)] + m3*im->green[(c3)] + m4*im->green[(c4)]); + b = (int)(m1*im->blue[(c1)] + m2*im->blue[(c2)] + m3*im->blue[(c3)] + m4*im->blue[(c4)]); + a = (int)(m1*im->alpha[(c1)] + m2*im->alpha[(c2)] + m3*im->alpha[(c3)] + m4*im->alpha[(c4)]); + } + + r = CLAMP(r, 0, 255); + g = CLAMP(g, 0, 255); + b = CLAMP(b, 0, 255); + a = CLAMP(a, 0, gdAlphaMax); + return gdTrueColorAlpha(r, g, b, a); +} + +/** + * InternalFunction: getPixelInterpolated + * Returns the interpolated color value using the default interpolation + * method. The returned color is always in the ARGB format (truecolor). + * + * Parameters: + * im - Image to set the default interpolation method + * y - X value of the ideal position + * y - Y value of the ideal position + * method - Interpolation method <gdInterpolationMethod> + * + * Returns: + * GD_TRUE if the affine is rectilinear or GD_FALSE + * + * See also: + * <gdSetInterpolationMethod> + */ +int getPixelInterpolated(gdImagePtr im, const double x, const double y, const int bgColor) +{ + const int xi=(int)((x) < 0 ? x - 1: x); + const int yi=(int)((y) < 0 ? y - 1: y); + int yii; + int i; + double kernel, kernel_cache_y; + double kernel_x[12], kernel_y[4]; + double new_r = 0.0f, new_g = 0.0f, new_b = 0.0f, new_a = 0.0f; + + /* These methods use special implementations */ + if (im->interpolation_id == GD_BILINEAR_FIXED || im->interpolation_id == GD_BICUBIC_FIXED || im->interpolation_id == GD_NEAREST_NEIGHBOUR) { + return -1; + } + + if (im->interpolation_id == GD_WEIGHTED4) { + return getPixelInterpolateWeight(im, x, y, bgColor); + } + + if (im->interpolation_id == GD_NEAREST_NEIGHBOUR) { + if (im->trueColor == 1) { + return getPixelOverflowTC(im, xi, yi, bgColor); + } else { + return getPixelOverflowPalette(im, xi, yi, bgColor); + } + } + if (im->interpolation) { + for (i=0; i<4; i++) { + kernel_x[i] = (double) im->interpolation((double)(xi+i-1-x)); + kernel_y[i] = (double) im->interpolation((double)(yi+i-1-y)); + } + } else { + return -1; + } + + /* + * TODO: use the known fast rgba multiplication implementation once + * the new formats are in place + */ + for (yii = yi-1; yii < yi+3; yii++) { + int xii; + kernel_cache_y = kernel_y[yii-(yi-1)]; + if (im->trueColor) { + for (xii=xi-1; xii<xi+3; xii++) { + const int rgbs = getPixelOverflowTC(im, xii, yii, bgColor); + + kernel = kernel_cache_y * kernel_x[xii-(xi-1)]; + new_r += kernel * gdTrueColorGetRed(rgbs); + new_g += kernel * gdTrueColorGetGreen(rgbs); + new_b += kernel * gdTrueColorGetBlue(rgbs); + new_a += kernel * gdTrueColorGetAlpha(rgbs); + } + } else { + for (xii=xi-1; xii<xi+3; xii++) { + const int rgbs = getPixelOverflowPalette(im, xii, yii, bgColor); + + kernel = kernel_cache_y * kernel_x[xii-(xi-1)]; + new_r += kernel * gdTrueColorGetRed(rgbs); + new_g += kernel * gdTrueColorGetGreen(rgbs); + new_b += kernel * gdTrueColorGetBlue(rgbs); + new_a += kernel * gdTrueColorGetAlpha(rgbs); + } + } + } + + new_r = CLAMP(new_r, 0, 255); + new_g = CLAMP(new_g, 0, 255); + new_b = CLAMP(new_b, 0, 255); + new_a = CLAMP(new_a, 0, gdAlphaMax); + + return gdTrueColorAlpha(((int)new_r), ((int)new_g), ((int)new_b), ((int)new_a)); +} + +static inline LineContribType * _gdContributionsAlloc(unsigned int line_length, unsigned int windows_size) +{ + unsigned int u = 0; + LineContribType *res; + + res = (LineContribType *) gdMalloc(sizeof(LineContribType)); + if (!res) { + return NULL; + } + res->WindowSize = windows_size; + res->LineLength = line_length; + res->ContribRow = (ContributionType *) gdMalloc(line_length * sizeof(ContributionType)); + + for (u = 0 ; u < line_length ; u++) { + res->ContribRow[u].Weights = (double *) gdMalloc(windows_size * sizeof(double)); + } + return res; +} + +static inline void _gdContributionsFree(LineContribType * p) +{ + unsigned int u; + for (u = 0; u < p->LineLength; u++) { + gdFree(p->ContribRow[u].Weights); + } + gdFree(p->ContribRow); + gdFree(p); +} + +static inline LineContribType *_gdContributionsCalc(unsigned int line_size, unsigned int src_size, double scale_d, const interpolation_method pFilter) +{ + double width_d; + double scale_f_d = 1.0; + const double filter_width_d = DEFAULT_BOX_RADIUS; + int windows_size; + unsigned int u; + LineContribType *res; + + if (scale_d < 1.0) { + width_d = filter_width_d / scale_d; + scale_f_d = scale_d; + } else { + width_d= filter_width_d; + } + + windows_size = 2 * (int)ceil(width_d) + 1; + res = _gdContributionsAlloc(line_size, windows_size); + + for (u = 0; u < line_size; u++) { + const double dCenter = (double)u / scale_d; + /* get the significant edge points affecting the pixel */ + register int iLeft = MAX(0, (int)floor (dCenter - width_d)); + int iRight = MIN((int)ceil(dCenter + width_d), (int)src_size - 1); + double dTotalWeight = 0.0; + int iSrc; + + /* Cut edge points to fit in filter window in case of spill-off */ + if (iRight - iLeft + 1 > windows_size) { + if (iLeft < ((int)src_size - 1 / 2)) { + iLeft++; + } else { + iRight--; + } + } + + res->ContribRow[u].Left = iLeft; + res->ContribRow[u].Right = iRight; + + for (iSrc = iLeft; iSrc <= iRight; iSrc++) { + dTotalWeight += (res->ContribRow[u].Weights[iSrc-iLeft] = scale_f_d * (*pFilter)(scale_f_d * (dCenter - (double)iSrc))); + } + + if (dTotalWeight < 0.0) { + _gdContributionsFree(res); + return NULL; + } + + if (dTotalWeight > 0.0) { + for (iSrc = iLeft; iSrc <= iRight; iSrc++) { + res->ContribRow[u].Weights[iSrc-iLeft] /= dTotalWeight; + } + } + } + return res; +} + + +static inline void +_gdScaleOneAxis(gdImagePtr pSrc, gdImagePtr dst, + unsigned int dst_len, unsigned int row, LineContribType *contrib, + gdAxis axis) +{ + unsigned int ndx; + + for (ndx = 0; ndx < dst_len; ndx++) { + double r = 0, g = 0, b = 0, a = 0; + const int left = contrib->ContribRow[ndx].Left; + const int right = contrib->ContribRow[ndx].Right; + int *dest = (axis == HORIZONTAL) ? + &dst->tpixels[row][ndx] : + &dst->tpixels[ndx][row]; + + int i; + + /* Accumulate each channel */ + for (i = left; i <= right; i++) { + const int left_channel = i - left; + const int srcpx = (axis == HORIZONTAL) ? + pSrc->tpixels[row][i] : + pSrc->tpixels[i][row]; + + r += contrib->ContribRow[ndx].Weights[left_channel] + * (double)(gdTrueColorGetRed(srcpx)); + g += contrib->ContribRow[ndx].Weights[left_channel] + * (double)(gdTrueColorGetGreen(srcpx)); + b += contrib->ContribRow[ndx].Weights[left_channel] + * (double)(gdTrueColorGetBlue(srcpx)); + a += contrib->ContribRow[ndx].Weights[left_channel] + * (double)(gdTrueColorGetAlpha(srcpx)); + }/* for */ + + *dest = gdTrueColorAlpha(uchar_clamp(r, 0xFF), uchar_clamp(g, 0xFF), + uchar_clamp(b, 0xFF), + uchar_clamp(a, 0x7F)); /* alpha is 0..127 */ + }/* for */ +}/* _gdScaleOneAxis*/ + + +static inline int +_gdScalePass(const gdImagePtr pSrc, const unsigned int src_len, + const gdImagePtr pDst, const unsigned int dst_len, + const unsigned int num_lines, + const gdAxis axis) +{ + unsigned int line_ndx; + LineContribType * contrib; + + /* Same dim, just copy it. */ + assert(dst_len != src_len); // TODO: caller should handle this. + + contrib = _gdContributionsCalc(dst_len, src_len, + (double)dst_len / (double)src_len, + pSrc->interpolation); + if (contrib == NULL) { + return 0; + } + + /* Scale each line */ + for (line_ndx = 0; line_ndx < num_lines; line_ndx++) { + _gdScaleOneAxis(pSrc, pDst, dst_len, line_ndx, contrib, axis); + } + _gdContributionsFree (contrib); + + return 1; +}/* _gdScalePass*/ + + +static gdImagePtr +gdImageScaleTwoPass(const gdImagePtr src, const unsigned int new_width, + const unsigned int new_height) +{ + const unsigned int src_width = src->sx; + const unsigned int src_height = src->sy; + gdImagePtr tmp_im = NULL;; + gdImagePtr dst = NULL; + + /* First, handle the trivial case. */ + if (src_width == new_width && src_height == new_height) { + return gdImageClone(src); + }/* if */ + + /* Convert to truecolor if it isn't; this code requires it. */ + if (!src->trueColor) { + gdImagePaletteToTrueColor(src); + }/* if */ + + /* Scale horizontally unless sizes are the same. */ + if (src_width == new_width) { + tmp_im = src; + } else { + tmp_im = gdImageCreateTrueColor(new_width, src_height); + if (tmp_im == NULL) { + return NULL; + } + gdImageSetInterpolationMethod(tmp_im, src->interpolation_id); + + _gdScalePass(src, src_width, tmp_im, new_width, src_height, HORIZONTAL); + }/* if .. else*/ + + /* If vertical sizes match, we're done. */ + if (src_height == new_height) { + assert(tmp_im != src); + return tmp_im; + }/* if */ + + /* Otherwise, we need to scale vertically. */ + dst = gdImageCreateTrueColor(new_width, new_height); + if (dst != NULL) { + gdImageSetInterpolationMethod(dst, src->interpolation_id); + _gdScalePass(tmp_im, src_height, dst, new_height, new_width, VERTICAL); + }/* if */ + + if (src != tmp_im) { + gdFree(tmp_im); + }/* if */ + + return dst; +}/* gdImageScaleTwoPass*/ + + +/* + BilinearFixed, BicubicFixed and nearest implementations are + rewamped versions of the implementation in CBitmapEx + + http://www.codeproject.com/Articles/29121/CBitmapEx-Free-C-Bitmap-Manipulation-Class + + Integer only implementation, good to have for common usages like + pre scale very large images before using another interpolation + methods for the last step. +*/ +static gdImagePtr +gdImageScaleNearestNeighbour(gdImagePtr im, const unsigned int width, const unsigned int height) +{ + const unsigned long new_width = MAX(1, width); + const unsigned long new_height = MAX(1, height); + const float dx = (float)im->sx / (float)new_width; + const float dy = (float)im->sy / (float)new_height; + const gdFixed f_dx = gd_ftofx(dx); + const gdFixed f_dy = gd_ftofx(dy); + + gdImagePtr dst_img; + unsigned long dst_offset_x; + unsigned long dst_offset_y = 0; + unsigned int i; + + dst_img = gdImageCreateTrueColor(new_width, new_height); + + if (dst_img == NULL) { + return NULL; + } + + for (i=0; i<new_height; i++) { + unsigned int j; + dst_offset_x = 0; + if (im->trueColor) { + for (j=0; j<new_width; j++) { + const gdFixed f_i = gd_itofx(i); + const gdFixed f_j = gd_itofx(j); + const gdFixed f_a = gd_mulfx(f_i, f_dy); + const gdFixed f_b = gd_mulfx(f_j, f_dx); + const long m = gd_fxtoi(f_a); + const long n = gd_fxtoi(f_b); + + dst_img->tpixels[dst_offset_y][dst_offset_x++] = im->tpixels[m][n]; + } + } else { + for (j=0; j<new_width; j++) { + const gdFixed f_i = gd_itofx(i); + const gdFixed f_j = gd_itofx(j); + const gdFixed f_a = gd_mulfx(f_i, f_dy); + const gdFixed f_b = gd_mulfx(f_j, f_dx); + const long m = gd_fxtoi(f_a); + const long n = gd_fxtoi(f_b); + + dst_img->tpixels[dst_offset_y][dst_offset_x++] = colorIndex2RGBA(im->pixels[m][n]); + } + } + dst_offset_y++; + } + return dst_img; +} + +static inline int getPixelOverflowColorTC(gdImagePtr im, const int x, const int y, const int color) +{ + if (gdImageBoundsSafe(im, x, y)) { + const int c = im->tpixels[y][x]; + if (c == im->transparent) { + return gdTrueColorAlpha(0, 0, 0, 127); + } + return c; + } else { + register int border = 0; + if (y < im->cy1) { + border = im->tpixels[0][im->cx1]; + goto processborder; + } + + if (y < im->cy1) { + border = im->tpixels[0][im->cx1]; + goto processborder; + } + + if (y > im->cy2) { + if (x >= im->cx1 && x <= im->cx1) { + border = im->tpixels[im->cy2][x]; + goto processborder; + } else { + return gdTrueColorAlpha(0, 0, 0, 127); + } + } + + /* y is bound safe at this point */ + if (x < im->cx1) { + border = im->tpixels[y][im->cx1]; + goto processborder; + } + + if (x > im->cx2) { + border = im->tpixels[y][im->cx2]; + } + +processborder: + if (border == im->transparent) { + return gdTrueColorAlpha(0, 0, 0, 127); + } else{ + return gdTrueColorAlpha(gdTrueColorGetRed(border), gdTrueColorGetGreen(border), gdTrueColorGetBlue(border), 127); + } + } +} + +static gdImagePtr gdImageScaleBilinearPalette(gdImagePtr im, const unsigned int new_width, const unsigned int new_height) +{ + long _width = MAX(1, new_width); + long _height = MAX(1, new_height); + float dx = (float)gdImageSX(im) / (float)_width; + float dy = (float)gdImageSY(im) / (float)_height; + gdFixed f_dx = gd_ftofx(dx); + gdFixed f_dy = gd_ftofx(dy); + gdFixed f_1 = gd_itofx(1); + + int dst_offset_h; + int dst_offset_v = 0; + long i; + gdImagePtr new_img; + const int transparent = im->transparent; + + new_img = gdImageCreateTrueColor(new_width, new_height); + if (new_img == NULL) { + return NULL; + } + new_img->transparent = gdTrueColorAlpha(im->red[transparent], im->green[transparent], im->blue[transparent], im->alpha[transparent]); + + for (i=0; i < _height; i++) { + long j; + const gdFixed f_i = gd_itofx(i); + const gdFixed f_a = gd_mulfx(f_i, f_dy); + register long m = gd_fxtoi(f_a); + + dst_offset_h = 0; + + for (j=0; j < _width; j++) { + /* Update bitmap */ + gdFixed f_j = gd_itofx(j); + gdFixed f_b = gd_mulfx(f_j, f_dx); + + const long n = gd_fxtoi(f_b); + gdFixed f_f = f_a - gd_itofx(m); + gdFixed f_g = f_b - gd_itofx(n); + + const gdFixed f_w1 = gd_mulfx(f_1-f_f, f_1-f_g); + const gdFixed f_w2 = gd_mulfx(f_1-f_f, f_g); + const gdFixed f_w3 = gd_mulfx(f_f, f_1-f_g); + const gdFixed f_w4 = gd_mulfx(f_f, f_g); + unsigned int pixel1; + unsigned int pixel2; + unsigned int pixel3; + unsigned int pixel4; + register gdFixed f_r1, f_r2, f_r3, f_r4, + f_g1, f_g2, f_g3, f_g4, + f_b1, f_b2, f_b3, f_b4, + f_a1, f_a2, f_a3, f_a4; + + /* zero for the background color, nothig gets outside anyway */ + pixel1 = getPixelOverflowPalette(im, n, m, 0); + pixel2 = getPixelOverflowPalette(im, n + 1, m, 0); + pixel3 = getPixelOverflowPalette(im, n, m + 1, 0); + pixel4 = getPixelOverflowPalette(im, n + 1, m + 1, 0); + + f_r1 = gd_itofx(gdTrueColorGetRed(pixel1)); + f_r2 = gd_itofx(gdTrueColorGetRed(pixel2)); + f_r3 = gd_itofx(gdTrueColorGetRed(pixel3)); + f_r4 = gd_itofx(gdTrueColorGetRed(pixel4)); + f_g1 = gd_itofx(gdTrueColorGetGreen(pixel1)); + f_g2 = gd_itofx(gdTrueColorGetGreen(pixel2)); + f_g3 = gd_itofx(gdTrueColorGetGreen(pixel3)); + f_g4 = gd_itofx(gdTrueColorGetGreen(pixel4)); + f_b1 = gd_itofx(gdTrueColorGetBlue(pixel1)); + f_b2 = gd_itofx(gdTrueColorGetBlue(pixel2)); + f_b3 = gd_itofx(gdTrueColorGetBlue(pixel3)); + f_b4 = gd_itofx(gdTrueColorGetBlue(pixel4)); + f_a1 = gd_itofx(gdTrueColorGetAlpha(pixel1)); + f_a2 = gd_itofx(gdTrueColorGetAlpha(pixel2)); + f_a3 = gd_itofx(gdTrueColorGetAlpha(pixel3)); + f_a4 = gd_itofx(gdTrueColorGetAlpha(pixel4)); + + { + const char red = (char) gd_fxtoi(gd_mulfx(f_w1, f_r1) + gd_mulfx(f_w2, f_r2) + gd_mulfx(f_w3, f_r3) + gd_mulfx(f_w4, f_r4)); + const char green = (char) gd_fxtoi(gd_mulfx(f_w1, f_g1) + gd_mulfx(f_w2, f_g2) + gd_mulfx(f_w3, f_g3) + gd_mulfx(f_w4, f_g4)); + const char blue = (char) gd_fxtoi(gd_mulfx(f_w1, f_b1) + gd_mulfx(f_w2, f_b2) + gd_mulfx(f_w3, f_b3) + gd_mulfx(f_w4, f_b4)); + const char alpha = (char) gd_fxtoi(gd_mulfx(f_w1, f_a1) + gd_mulfx(f_w2, f_a2) + gd_mulfx(f_w3, f_a3) + gd_mulfx(f_w4, f_a4)); + + new_img->tpixels[dst_offset_v][dst_offset_h] = gdTrueColorAlpha(red, green, blue, alpha); + } + + dst_offset_h++; + } + + dst_offset_v++; + } + return new_img; +} + +static gdImagePtr gdImageScaleBilinearTC(gdImagePtr im, const unsigned int new_width, const unsigned int new_height) +{ + long dst_w = MAX(1, new_width); + long dst_h = MAX(1, new_height); + float dx = (float)gdImageSX(im) / (float)dst_w; + float dy = (float)gdImageSY(im) / (float)dst_h; + gdFixed f_dx = gd_ftofx(dx); + gdFixed f_dy = gd_ftofx(dy); + gdFixed f_1 = gd_itofx(1); + + int dst_offset_h; + int dst_offset_v = 0; + long i; + gdImagePtr new_img; + + new_img = gdImageCreateTrueColor(new_width, new_height); + if (!new_img){ + return NULL; + } + + for (i=0; i < dst_h; i++) { + long j; + dst_offset_h = 0; + for (j=0; j < dst_w; j++) { + /* Update bitmap */ + gdFixed f_i = gd_itofx(i); + gdFixed f_j = gd_itofx(j); + gdFixed f_a = gd_mulfx(f_i, f_dy); + gdFixed f_b = gd_mulfx(f_j, f_dx); + const gdFixed m = gd_fxtoi(f_a); + const gdFixed n = gd_fxtoi(f_b); + gdFixed f_f = f_a - gd_itofx(m); + gdFixed f_g = f_b - gd_itofx(n); + + const gdFixed f_w1 = gd_mulfx(f_1-f_f, f_1-f_g); + const gdFixed f_w2 = gd_mulfx(f_1-f_f, f_g); + const gdFixed f_w3 = gd_mulfx(f_f, f_1-f_g); + const gdFixed f_w4 = gd_mulfx(f_f, f_g); + unsigned int pixel1; + unsigned int pixel2; + unsigned int pixel3; + unsigned int pixel4; + register gdFixed f_r1, f_r2, f_r3, f_r4, + f_g1, f_g2, f_g3, f_g4, + f_b1, f_b2, f_b3, f_b4, + f_a1, f_a2, f_a3, f_a4; + /* 0 for bgColor, nothing gets outside anyway */ + pixel1 = getPixelOverflowTC(im, n, m, 0); + pixel2 = getPixelOverflowTC(im, n + 1, m, 0); + pixel3 = getPixelOverflowTC(im, n, m + 1, 0); + pixel4 = getPixelOverflowTC(im, n + 1, m + 1, 0); + + f_r1 = gd_itofx(gdTrueColorGetRed(pixel1)); + f_r2 = gd_itofx(gdTrueColorGetRed(pixel2)); + f_r3 = gd_itofx(gdTrueColorGetRed(pixel3)); + f_r4 = gd_itofx(gdTrueColorGetRed(pixel4)); + f_g1 = gd_itofx(gdTrueColorGetGreen(pixel1)); + f_g2 = gd_itofx(gdTrueColorGetGreen(pixel2)); + f_g3 = gd_itofx(gdTrueColorGetGreen(pixel3)); + f_g4 = gd_itofx(gdTrueColorGetGreen(pixel4)); + f_b1 = gd_itofx(gdTrueColorGetBlue(pixel1)); + f_b2 = gd_itofx(gdTrueColorGetBlue(pixel2)); + f_b3 = gd_itofx(gdTrueColorGetBlue(pixel3)); + f_b4 = gd_itofx(gdTrueColorGetBlue(pixel4)); + f_a1 = gd_itofx(gdTrueColorGetAlpha(pixel1)); + f_a2 = gd_itofx(gdTrueColorGetAlpha(pixel2)); + f_a3 = gd_itofx(gdTrueColorGetAlpha(pixel3)); + f_a4 = gd_itofx(gdTrueColorGetAlpha(pixel4)); + { + const unsigned char red = (unsigned char) gd_fxtoi(gd_mulfx(f_w1, f_r1) + gd_mulfx(f_w2, f_r2) + gd_mulfx(f_w3, f_r3) + gd_mulfx(f_w4, f_r4)); + const unsigned char green = (unsigned char) gd_fxtoi(gd_mulfx(f_w1, f_g1) + gd_mulfx(f_w2, f_g2) + gd_mulfx(f_w3, f_g3) + gd_mulfx(f_w4, f_g4)); + const unsigned char blue = (unsigned char) gd_fxtoi(gd_mulfx(f_w1, f_b1) + gd_mulfx(f_w2, f_b2) + gd_mulfx(f_w3, f_b3) + gd_mulfx(f_w4, f_b4)); + const unsigned char alpha = (unsigned char) gd_fxtoi(gd_mulfx(f_w1, f_a1) + gd_mulfx(f_w2, f_a2) + gd_mulfx(f_w3, f_a3) + gd_mulfx(f_w4, f_a4)); + + new_img->tpixels[dst_offset_v][dst_offset_h] = gdTrueColorAlpha(red, green, blue, alpha); + } + + dst_offset_h++; + } + + dst_offset_v++; + } + return new_img; +} + +static gdImagePtr +gdImageScaleBilinear(gdImagePtr im, const unsigned int new_width, + const unsigned int new_height) +{ + if (im->trueColor) { + return gdImageScaleBilinearTC(im, new_width, new_height); + } else { + return gdImageScaleBilinearPalette(im, new_width, new_height); + } +} + +static gdImagePtr +gdImageScaleBicubicFixed(gdImagePtr src, const unsigned int width, + const unsigned int height) +{ + const long new_width = MAX(1, width); + const long new_height = MAX(1, height); + const int src_w = gdImageSX(src); + const int src_h = gdImageSY(src); + const gdFixed f_dx = gd_ftofx((float)src_w / (float)new_width); + const gdFixed f_dy = gd_ftofx((float)src_h / (float)new_height); + const gdFixed f_1 = gd_itofx(1); + const gdFixed f_2 = gd_itofx(2); + const gdFixed f_4 = gd_itofx(4); + const gdFixed f_6 = gd_itofx(6); + const gdFixed f_gamma = gd_ftofx(1.04f); + gdImagePtr dst; + + unsigned int dst_offset_x; + unsigned int dst_offset_y = 0; + long i; + + /* impact perf a bit, but not that much. Implementation for palette + images can be done at a later point. + */ + if (src->trueColor == 0) { + gdImagePaletteToTrueColor(src); + } + + dst = gdImageCreateTrueColor(new_width, new_height); + if (!dst) { + return NULL; + } + + dst->saveAlphaFlag = 1; + + for (i=0; i < new_height; i++) { + long j; + dst_offset_x = 0; + + for (j=0; j < new_width; j++) { + const gdFixed f_a = gd_mulfx(gd_itofx(i), f_dy); + const gdFixed f_b = gd_mulfx(gd_itofx(j), f_dx); + const long m = gd_fxtoi(f_a); + const long n = gd_fxtoi(f_b); + const gdFixed f_f = f_a - gd_itofx(m); + const gdFixed f_g = f_b - gd_itofx(n); + unsigned int src_offset_x[16], src_offset_y[16]; + long k; + register gdFixed f_red = 0, f_green = 0, f_blue = 0, f_alpha = 0; + unsigned char red, green, blue, alpha = 0; + int *dst_row = dst->tpixels[dst_offset_y]; + + if ((m < 1) || (n < 1)) { + src_offset_x[0] = n; + src_offset_y[0] = m; + } else { + src_offset_x[0] = n - 1; + src_offset_y[0] = m; + } + + if (m < 1) { + src_offset_x[1] = n; + src_offset_y[1] = m; + } else { + src_offset_x[1] = n; + src_offset_y[1] = m; + } + + if ((m < 1) || (n >= src_w - 1)) { + src_offset_x[2] = n; + src_offset_y[2] = m; + } else { + src_offset_x[2] = n + 1; + src_offset_y[2] = m; + } + + if ((m < 1) || (n >= src_w - 2)) { + src_offset_x[3] = n; + src_offset_y[3] = m; + } else { + src_offset_x[3] = n + 1 + 1; + src_offset_y[3] = m; + } + + if (n < 1) { + src_offset_x[4] = n; + src_offset_y[4] = m; + } else { + src_offset_x[4] = n - 1; + src_offset_y[4] = m; + } + + src_offset_x[5] = n; + src_offset_y[5] = m; + if (n >= src_w-1) { + src_offset_x[6] = n; + src_offset_y[6] = m; + } else { + src_offset_x[6] = n + 1; + src_offset_y[6] = m; + } + + if (n >= src_w - 2) { + src_offset_x[7] = n; + src_offset_y[7] = m; + } else { + src_offset_x[7] = n + 1 + 1; + src_offset_y[7] = m; + } + + if ((m >= src_h - 1) || (n < 1)) { + src_offset_x[8] = n; + src_offset_y[8] = m; + } else { + src_offset_x[8] = n - 1; + src_offset_y[8] = m; + } + + if (m >= src_h - 1) { + src_offset_x[8] = n; + src_offset_y[8] = m; + } else { + src_offset_x[9] = n; + src_offset_y[9] = m; + } + + if ((m >= src_h-1) || (n >= src_w-1)) { + src_offset_x[10] = n; + src_offset_y[10] = m; + } else { + src_offset_x[10] = n + 1; + src_offset_y[10] = m; + } + + if ((m >= src_h - 1) || (n >= src_w - 2)) { + src_offset_x[11] = n; + src_offset_y[11] = m; + } else { + src_offset_x[11] = n + 1 + 1; + src_offset_y[11] = m; + } + + if ((m >= src_h - 2) || (n < 1)) { + src_offset_x[12] = n; + src_offset_y[12] = m; + } else { + src_offset_x[12] = n - 1; + src_offset_y[12] = m; + } + + if (m >= src_h - 2) { + src_offset_x[13] = n; + src_offset_y[13] = m; + } else { + src_offset_x[13] = n; + src_offset_y[13] = m; + } + + if ((m >= src_h - 2) || (n >= src_w - 1)) { + src_offset_x[14] = n; + src_offset_y[14] = m; + } else { + src_offset_x[14] = n + 1; + src_offset_y[14] = m; + } + + if ((m >= src_h - 2) || (n >= src_w - 2)) { + src_offset_x[15] = n; + src_offset_y[15] = m; + } else { + src_offset_x[15] = n + 1 + 1; + src_offset_y[15] = m; + } + + for (k = -1; k < 3; k++) { + const gdFixed f = gd_itofx(k)-f_f; + const gdFixed f_fm1 = f - f_1; + const gdFixed f_fp1 = f + f_1; + const gdFixed f_fp2 = f + f_2; + register gdFixed f_a = 0, f_b = 0, f_d = 0, f_c = 0; + register gdFixed f_RY; + int l; + + if (f_fp2 > 0) f_a = gd_mulfx(f_fp2, gd_mulfx(f_fp2,f_fp2)); + if (f_fp1 > 0) f_b = gd_mulfx(f_fp1, gd_mulfx(f_fp1,f_fp1)); + if (f > 0) f_c = gd_mulfx(f, gd_mulfx(f,f)); + if (f_fm1 > 0) f_d = gd_mulfx(f_fm1, gd_mulfx(f_fm1,f_fm1)); + + f_RY = gd_divfx((f_a - gd_mulfx(f_4,f_b) + gd_mulfx(f_6,f_c) - gd_mulfx(f_4,f_d)),f_6); + + for (l = -1; l < 3; l++) { + const gdFixed f = gd_itofx(l) - f_g; + const gdFixed f_fm1 = f - f_1; + const gdFixed f_fp1 = f + f_1; + const gdFixed f_fp2 = f + f_2; + register gdFixed f_a = 0, f_b = 0, f_c = 0, f_d = 0; + register gdFixed f_RX, f_R, f_rs, f_gs, f_bs, f_ba; + register int c; + const int _k = ((k+1)*4) + (l+1); + + if (f_fp2 > 0) f_a = gd_mulfx(f_fp2,gd_mulfx(f_fp2,f_fp2)); + + if (f_fp1 > 0) f_b = gd_mulfx(f_fp1,gd_mulfx(f_fp1,f_fp1)); + + if (f > 0) f_c = gd_mulfx(f,gd_mulfx(f,f)); + + if (f_fm1 > 0) f_d = gd_mulfx(f_fm1,gd_mulfx(f_fm1,f_fm1)); + + f_RX = gd_divfx((f_a-gd_mulfx(f_4,f_b)+gd_mulfx(f_6,f_c)-gd_mulfx(f_4,f_d)),f_6); + f_R = gd_mulfx(f_RY,f_RX); + + c = src->tpixels[*(src_offset_y + _k)][*(src_offset_x + _k)]; + f_rs = gd_itofx(gdTrueColorGetRed(c)); + f_gs = gd_itofx(gdTrueColorGetGreen(c)); + f_bs = gd_itofx(gdTrueColorGetBlue(c)); + f_ba = gd_itofx(gdTrueColorGetAlpha(c)); + + f_red += gd_mulfx(f_rs,f_R); + f_green += gd_mulfx(f_gs,f_R); + f_blue += gd_mulfx(f_bs,f_R); + f_alpha += gd_mulfx(f_ba,f_R); + } + } + + red = (unsigned char) CLAMP(gd_fxtoi(gd_mulfx(f_red, f_gamma)), 0, 255); + green = (unsigned char) CLAMP(gd_fxtoi(gd_mulfx(f_green, f_gamma)), 0, 255); + blue = (unsigned char) CLAMP(gd_fxtoi(gd_mulfx(f_blue, f_gamma)), 0, 255); + alpha = (unsigned char) CLAMP(gd_fxtoi(gd_mulfx(f_alpha, f_gamma)), 0, 127); + + *(dst_row + dst_offset_x) = gdTrueColorAlpha(red, green, blue, alpha); + + dst_offset_x++; + } + dst_offset_y++; + } + return dst; +} + +BGD_DECLARE(gdImagePtr) gdImageScale(const gdImagePtr src, const unsigned int new_width, const unsigned int new_height) +{ + gdImagePtr im_scaled = NULL; + + if (src == NULL || src->interpolation_id < 0 || src->interpolation_id > GD_METHOD_COUNT) { + return 0; + } + + switch (src->interpolation_id) { + /*Special cases, optimized implementations */ + case GD_NEAREST_NEIGHBOUR: + im_scaled = gdImageScaleNearestNeighbour(src, new_width, new_height); + break; + + case GD_BILINEAR_FIXED: + im_scaled = gdImageScaleBilinear(src, new_width, new_height); + break; + + case GD_BICUBIC_FIXED: + im_scaled = gdImageScaleBicubicFixed(src, new_width, new_height); + break; + + /* generic */ + default: + if (src->interpolation == NULL) { + return NULL; + } + im_scaled = gdImageScaleTwoPass(src, new_width, new_height); + break; + } + + return im_scaled; +} + +static gdImagePtr +gdImageRotateNearestNeighbour(gdImagePtr src, const float degrees, + const int bgColor) +{ + float _angle = ((float) (-degrees / 180.0f) * (float)M_PI); + const int src_w = gdImageSX(src); + const int src_h = gdImageSY(src); + const unsigned int new_width = (unsigned int)(abs((int)(src_w * cos(_angle))) + abs((int)(src_h * sin(_angle))) + 0.5f); + const unsigned int new_height = (unsigned int)(abs((int)(src_w * sin(_angle))) + abs((int)(src_h * cos(_angle))) + 0.5f); + const gdFixed f_0_5 = gd_ftofx(0.5f); + const gdFixed f_H = gd_itofx(src_h/2); + const gdFixed f_W = gd_itofx(src_w/2); + const gdFixed f_cos = gd_ftofx(cos(-_angle)); + const gdFixed f_sin = gd_ftofx(sin(-_angle)); + + unsigned int dst_offset_x; + unsigned int dst_offset_y = 0; + unsigned int i; + gdImagePtr dst; + + /* impact perf a bit, but not that much. Implementation for palette + images can be done at a later point. + */ + if (src->trueColor == 0) { + gdImagePaletteToTrueColor(src); + } + + dst = gdImageCreateTrueColor(new_width, new_height); + if (!dst) { + return NULL; + } + dst->saveAlphaFlag = 1; + for (i = 0; i < new_height; i++) { + unsigned int j; + dst_offset_x = 0; + for (j = 0; j < new_width; j++) { + gdFixed f_i = gd_itofx((int)i - (int)new_height / 2); + gdFixed f_j = gd_itofx((int)j - (int)new_width / 2); + gdFixed f_m = gd_mulfx(f_j,f_sin) + gd_mulfx(f_i,f_cos) + f_0_5 + f_H; + gdFixed f_n = gd_mulfx(f_j,f_cos) - gd_mulfx(f_i,f_sin) + f_0_5 + f_W; + long m = gd_fxtoi(f_m); + long n = gd_fxtoi(f_n); + + if ((m > 0) && (m < src_h-1) && (n > 0) && (n < src_w-1)) { + if (dst_offset_y < new_height) { + dst->tpixels[dst_offset_y][dst_offset_x++] = src->tpixels[m][n]; + } + } else { + if (dst_offset_y < new_height) { + dst->tpixels[dst_offset_y][dst_offset_x++] = bgColor; + } + } + } + dst_offset_y++; + } + return dst; +} + +static gdImagePtr +gdImageRotateGeneric(gdImagePtr src, const float degrees, const int bgColor) +{ + float _angle = ((float) (-degrees / 180.0f) * (float)M_PI); + const int src_w = gdImageSX(src); + const int src_h = gdImageSY(src); + const unsigned int new_width = (unsigned int)(abs((int)(src_w * cos(_angle))) + abs((int)(src_h * sin(_angle))) + 0.5f); + const unsigned int new_height = (unsigned int)(abs((int)(src_w * sin(_angle))) + abs((int)(src_h * cos(_angle))) + 0.5f); + const gdFixed f_0_5 = gd_ftofx(0.5f); + const gdFixed f_H = gd_itofx(src_h/2); + const gdFixed f_W = gd_itofx(src_w/2); + const gdFixed f_cos = gd_ftofx(cos(-_angle)); + const gdFixed f_sin = gd_ftofx(sin(-_angle)); + + unsigned int dst_offset_x; + unsigned int dst_offset_y = 0; + unsigned int i; + gdImagePtr dst; + + const gdFixed f_slop_y = f_sin; + const gdFixed f_slop_x = f_cos; + const gdFixed f_slop = f_slop_x > 0 && f_slop_x > 0 ? + f_slop_x > f_slop_y ? gd_divfx(f_slop_y, f_slop_x) : gd_divfx(f_slop_x, f_slop_y) + : 0; + + if (bgColor < 0) { + return NULL; + } + + /* impact perf a bit, but not that much. Implementation for palette + images can be done at a later point. + */ + if (src->trueColor == 0) { + gdImagePaletteToTrueColor(src); + } + + dst = gdImageCreateTrueColor(new_width, new_height); + if (!dst) { + return NULL; + } + dst->saveAlphaFlag = 1; + + for (i = 0; i < new_height; i++) { + unsigned int j; + dst_offset_x = 0; + for (j = 0; j < new_width; j++) { + gdFixed f_i = gd_itofx((int)i - (int)new_height / 2); + gdFixed f_j = gd_itofx((int)j - (int)new_width / 2); + gdFixed f_m = gd_mulfx(f_j,f_sin) + gd_mulfx(f_i,f_cos) + f_0_5 + f_H; + gdFixed f_n = gd_mulfx(f_j,f_cos) - gd_mulfx(f_i,f_sin) + f_0_5 + f_W; + long m = gd_fxtoi(f_m); + long n = gd_fxtoi(f_n); + + if ((n <= 0) || (m <= 0) || (m >= src_h) || (n >= src_w)) { + dst->tpixels[dst_offset_y][dst_offset_x++] = bgColor; + } else if ((n <= 1) || (m <= 1) || (m >= src_h - 1) || (n >= src_w - 1)) { + register int c = getPixelInterpolated(src, n, m, bgColor); + c = c | (( gdTrueColorGetAlpha(c) + ((int)(127* gd_fxtof(f_slop)))) << 24); + + dst->tpixels[dst_offset_y][dst_offset_x++] = _color_blend(bgColor, c); + } else { + dst->tpixels[dst_offset_y][dst_offset_x++] = getPixelInterpolated(src, n, m, bgColor); + } + } + dst_offset_y++; + } + return dst; +} + +static gdImagePtr +gdImageRotateBilinear(gdImagePtr src, const float degrees, const int bgColor) +{ + float _angle = (float)((- degrees / 180.0f) * M_PI); + const unsigned int src_w = gdImageSX(src); + const unsigned int src_h = gdImageSY(src); + unsigned int new_width = abs((int)(src_w*cos(_angle))) + abs((int)(src_h*sin(_angle) + 0.5f)); + unsigned int new_height = abs((int)(src_w*sin(_angle))) + abs((int)(src_h*cos(_angle) + 0.5f)); + const gdFixed f_0_5 = gd_ftofx(0.5f); + const gdFixed f_H = gd_itofx(src_h/2); + const gdFixed f_W = gd_itofx(src_w/2); + const gdFixed f_cos = gd_ftofx(cos(-_angle)); + const gdFixed f_sin = gd_ftofx(sin(-_angle)); + const gdFixed f_1 = gd_itofx(1); + unsigned int i; + unsigned int dst_offset_x; + unsigned int dst_offset_y = 0; + unsigned int src_offset_x, src_offset_y; + gdImagePtr dst; + + /* impact perf a bit, but not that much. Implementation for palette + images can be done at a later point. + */ + if (src->trueColor == 0) { + gdImagePaletteToTrueColor(src); + } + + dst = gdImageCreateTrueColor(new_width, new_height); + if (dst == NULL) { + return NULL; + } + dst->saveAlphaFlag = 1; + + for (i = 0; i < new_height; i++) { + unsigned int j; + dst_offset_x = 0; + + for (j=0; j < new_width; j++) { + const gdFixed f_i = gd_itofx((int)i - (int)new_height / 2); + const gdFixed f_j = gd_itofx((int)j - (int)new_width / 2); + const gdFixed f_m = gd_mulfx(f_j,f_sin) + gd_mulfx(f_i,f_cos) + f_0_5 + f_H; + const gdFixed f_n = gd_mulfx(f_j,f_cos) - gd_mulfx(f_i,f_sin) + f_0_5 + f_W; + const unsigned int m = gd_fxtoi(f_m); + const unsigned int n = gd_fxtoi(f_n); + + if ((m > 0) && (m < src_h - 1) && (n > 0) && (n < src_w - 1)) { + const gdFixed f_f = f_m - gd_itofx(m); + const gdFixed f_g = f_n - gd_itofx(n); + const gdFixed f_w1 = gd_mulfx(f_1-f_f, f_1-f_g); + const gdFixed f_w2 = gd_mulfx(f_1-f_f, f_g); + const gdFixed f_w3 = gd_mulfx(f_f, f_1-f_g); + const gdFixed f_w4 = gd_mulfx(f_f, f_g); + + if (n < src_w - 1) { + src_offset_x = n + 1; + src_offset_y = m; + } + + if (m < src_h - 1) { + src_offset_x = n; + src_offset_y = m + 1; + } + + if (!((n >= src_w - 1) || (m >= src_h - 1))) { + src_offset_x = n + 1; + src_offset_y = m + 1; + } + { + const int pixel1 = src->tpixels[src_offset_y][src_offset_x]; + register int pixel2, pixel3, pixel4; + + if (src_offset_y + 1 >= src_h) { + pixel2 = bgColor; + pixel3 = bgColor; + pixel4 = bgColor; + } else if (src_offset_x + 1 >= src_w) { + pixel2 = bgColor; + pixel3 = bgColor; + pixel4 = bgColor; + } else { + pixel2 = src->tpixels[src_offset_y][src_offset_x + 1]; + pixel3 = src->tpixels[src_offset_y + 1][src_offset_x]; + pixel4 = src->tpixels[src_offset_y + 1][src_offset_x + 1]; + } + { + const gdFixed f_r1 = gd_itofx(gdTrueColorGetRed(pixel1)); + const gdFixed f_r2 = gd_itofx(gdTrueColorGetRed(pixel2)); + const gdFixed f_r3 = gd_itofx(gdTrueColorGetRed(pixel3)); + const gdFixed f_r4 = gd_itofx(gdTrueColorGetRed(pixel4)); + const gdFixed f_g1 = gd_itofx(gdTrueColorGetGreen(pixel1)); + const gdFixed f_g2 = gd_itofx(gdTrueColorGetGreen(pixel2)); + const gdFixed f_g3 = gd_itofx(gdTrueColorGetGreen(pixel3)); + const gdFixed f_g4 = gd_itofx(gdTrueColorGetGreen(pixel4)); + const gdFixed f_b1 = gd_itofx(gdTrueColorGetBlue(pixel1)); + const gdFixed f_b2 = gd_itofx(gdTrueColorGetBlue(pixel2)); + const gdFixed f_b3 = gd_itofx(gdTrueColorGetBlue(pixel3)); + const gdFixed f_b4 = gd_itofx(gdTrueColorGetBlue(pixel4)); + const gdFixed f_a1 = gd_itofx(gdTrueColorGetAlpha(pixel1)); + const gdFixed f_a2 = gd_itofx(gdTrueColorGetAlpha(pixel2)); + const gdFixed f_a3 = gd_itofx(gdTrueColorGetAlpha(pixel3)); + const gdFixed f_a4 = gd_itofx(gdTrueColorGetAlpha(pixel4)); + const gdFixed f_red = gd_mulfx(f_w1, f_r1) + gd_mulfx(f_w2, f_r2) + gd_mulfx(f_w3, f_r3) + gd_mulfx(f_w4, f_r4); + const gdFixed f_green = gd_mulfx(f_w1, f_g1) + gd_mulfx(f_w2, f_g2) + gd_mulfx(f_w3, f_g3) + gd_mulfx(f_w4, f_g4); + const gdFixed f_blue = gd_mulfx(f_w1, f_b1) + gd_mulfx(f_w2, f_b2) + gd_mulfx(f_w3, f_b3) + gd_mulfx(f_w4, f_b4); + const gdFixed f_alpha = gd_mulfx(f_w1, f_a1) + gd_mulfx(f_w2, f_a2) + gd_mulfx(f_w3, f_a3) + gd_mulfx(f_w4, f_a4); + + const unsigned char red = (unsigned char) CLAMP(gd_fxtoi(f_red), 0, 255); + const unsigned char green = (unsigned char) CLAMP(gd_fxtoi(f_green), 0, 255); + const unsigned char blue = (unsigned char) CLAMP(gd_fxtoi(f_blue), 0, 255); + const unsigned char alpha = (unsigned char) CLAMP(gd_fxtoi(f_alpha), 0, 127); + + dst->tpixels[dst_offset_y][dst_offset_x++] = gdTrueColorAlpha(red, green, blue, alpha); + } + } + } else { + dst->tpixels[dst_offset_y][dst_offset_x++] = bgColor; + } + } + dst_offset_y++; + } + return dst; +} + +static gdImagePtr +gdImageRotateBicubicFixed(gdImagePtr src, const float degrees,const int bgColor) +{ + const float _angle = (float)((- degrees / 180.0f) * M_PI); + const int src_w = gdImageSX(src); + const int src_h = gdImageSY(src); + const unsigned int new_width = abs((int)(src_w*cos(_angle))) + abs((int)(src_h*sin(_angle) + 0.5f)); + const unsigned int new_height = abs((int)(src_w*sin(_angle))) + abs((int)(src_h*cos(_angle) + 0.5f)); + const gdFixed f_0_5 = gd_ftofx(0.5f); + const gdFixed f_H = gd_itofx(src_h/2); + const gdFixed f_W = gd_itofx(src_w/2); + const gdFixed f_cos = gd_ftofx(cos(-_angle)); + const gdFixed f_sin = gd_ftofx(sin(-_angle)); + const gdFixed f_1 = gd_itofx(1); + const gdFixed f_2 = gd_itofx(2); + const gdFixed f_4 = gd_itofx(4); + const gdFixed f_6 = gd_itofx(6); + const gdFixed f_gama = gd_ftofx(1.04f); + + unsigned int dst_offset_x; + unsigned int dst_offset_y = 0; + unsigned int i; + gdImagePtr dst; + + /* impact perf a bit, but not that much. Implementation for palette + images can be done at a later point. + */ + if (src->trueColor == 0) { + gdImagePaletteToTrueColor(src); + } + + dst = gdImageCreateTrueColor(new_width, new_height); + + if (dst == NULL) { + return NULL; + } + dst->saveAlphaFlag = 1; + + for (i=0; i < new_height; i++) { + unsigned int j; + dst_offset_x = 0; + + for (j=0; j < new_width; j++) { + const gdFixed f_i = gd_itofx((int)i - (int)new_height / 2); + const gdFixed f_j = gd_itofx((int)j - (int)new_width / 2); + const gdFixed f_m = gd_mulfx(f_j,f_sin) + gd_mulfx(f_i,f_cos) + f_0_5 + f_H; + const gdFixed f_n = gd_mulfx(f_j,f_cos) - gd_mulfx(f_i,f_sin) + f_0_5 + f_W; + const int m = gd_fxtoi(f_m); + const int n = gd_fxtoi(f_n); + + if ((m > 0) && (m < src_h - 1) && (n > 0) && (n < src_w-1)) { + const gdFixed f_f = f_m - gd_itofx(m); + const gdFixed f_g = f_n - gd_itofx(n); + unsigned int src_offset_x[16], src_offset_y[16]; + unsigned char red, green, blue, alpha; + gdFixed f_red=0, f_green=0, f_blue=0, f_alpha=0; + int k; + + if ((m < 1) || (n < 1)) { + src_offset_x[0] = n; + src_offset_y[0] = m; + } else { + src_offset_x[0] = n - 1; + src_offset_y[0] = m; + } + + if (m < 1) { + src_offset_x[1] = n; + src_offset_y[1] = m; + } else { + src_offset_x[1] = n; + src_offset_y[1] = m ; + } + + if ((m < 1) || (n >= src_w-1)) { + src_offset_x[2] = - 1; + src_offset_y[2] = - 1; + } else { + src_offset_x[2] = n + 1; + src_offset_y[2] = m ; + } + + if ((m < 1) || (n >= src_w-2)) { + src_offset_x[3] = - 1; + src_offset_y[3] = - 1; + } else { + src_offset_x[3] = n + 1 + 1; + src_offset_y[3] = m ; + } + + if (n < 1) { + src_offset_x[4] = - 1; + src_offset_y[4] = - 1; + } else { + src_offset_x[4] = n - 1; + src_offset_y[4] = m; + } + + src_offset_x[5] = n; + src_offset_y[5] = m; + if (n >= src_w-1) { + src_offset_x[6] = - 1; + src_offset_y[6] = - 1; + } else { + src_offset_x[6] = n + 1; + src_offset_y[6] = m; + } + + if (n >= src_w-2) { + src_offset_x[7] = - 1; + src_offset_y[7] = - 1; + } else { + src_offset_x[7] = n + 1 + 1; + src_offset_y[7] = m; + } + + if ((m >= src_h-1) || (n < 1)) { + src_offset_x[8] = - 1; + src_offset_y[8] = - 1; + } else { + src_offset_x[8] = n - 1; + src_offset_y[8] = m; + } + + if (m >= src_h-1) { + src_offset_x[8] = - 1; + src_offset_y[8] = - 1; + } else { + src_offset_x[9] = n; + src_offset_y[9] = m; + } + + if ((m >= src_h-1) || (n >= src_w-1)) { + src_offset_x[10] = - 1; + src_offset_y[10] = - 1; + } else { + src_offset_x[10] = n + 1; + src_offset_y[10] = m; + } + + if ((m >= src_h-1) || (n >= src_w-2)) { + src_offset_x[11] = - 1; + src_offset_y[11] = - 1; + } else { + src_offset_x[11] = n + 1 + 1; + src_offset_y[11] = m; + } + + if ((m >= src_h-2) || (n < 1)) { + src_offset_x[12] = - 1; + src_offset_y[12] = - 1; + } else { + src_offset_x[12] = n - 1; + src_offset_y[12] = m; + } + + if (m >= src_h-2) { + src_offset_x[13] = - 1; + src_offset_y[13] = - 1; + } else { + src_offset_x[13] = n; + src_offset_y[13] = m; + } + + if ((m >= src_h-2) || (n >= src_w - 1)) { + src_offset_x[14] = - 1; + src_offset_y[14] = - 1; + } else { + src_offset_x[14] = n + 1; + src_offset_y[14] = m; + } + + if ((m >= src_h-2) || (n >= src_w-2)) { + src_offset_x[15] = - 1; + src_offset_y[15] = - 1; + } else { + src_offset_x[15] = n + 1 + 1; + src_offset_y[15] = m; + } + + for (k=-1; k<3; k++) { + const gdFixed f = gd_itofx(k)-f_f; + const gdFixed f_fm1 = f - f_1; + const gdFixed f_fp1 = f + f_1; + const gdFixed f_fp2 = f + f_2; + gdFixed f_a = 0, f_b = 0,f_c = 0, f_d = 0; + gdFixed f_RY; + int l; + + if (f_fp2 > 0) { + f_a = gd_mulfx(f_fp2,gd_mulfx(f_fp2,f_fp2)); + } + + if (f_fp1 > 0) { + f_b = gd_mulfx(f_fp1,gd_mulfx(f_fp1,f_fp1)); + } + + if (f > 0) { + f_c = gd_mulfx(f,gd_mulfx(f,f)); + } + + if (f_fm1 > 0) { + f_d = gd_mulfx(f_fm1,gd_mulfx(f_fm1,f_fm1)); + } + f_RY = gd_divfx((f_a-gd_mulfx(f_4,f_b)+gd_mulfx(f_6,f_c)-gd_mulfx(f_4,f_d)),f_6); + + for (l=-1; l< 3; l++) { + const gdFixed f = gd_itofx(l) - f_g; + const gdFixed f_fm1 = f - f_1; + const gdFixed f_fp1 = f + f_1; + const gdFixed f_fp2 = f + f_2; + gdFixed f_a = 0, f_b = 0, f_c = 0, f_d = 0; + gdFixed f_RX, f_R; + const int _k = ((k + 1) * 4) + (l + 1); + register gdFixed f_rs, f_gs, f_bs, f_as; + register int c; + + if (f_fp2 > 0) { + f_a = gd_mulfx(f_fp2,gd_mulfx(f_fp2,f_fp2)); + } + + if (f_fp1 > 0) { + f_b = gd_mulfx(f_fp1,gd_mulfx(f_fp1,f_fp1)); + } + + if (f > 0) { + f_c = gd_mulfx(f,gd_mulfx(f,f)); + } + + if (f_fm1 > 0) { + f_d = gd_mulfx(f_fm1,gd_mulfx(f_fm1,f_fm1)); + } + + f_RX = gd_divfx((f_a - gd_mulfx(f_4, f_b) + gd_mulfx(f_6, f_c) - gd_mulfx(f_4, f_d)), f_6); + f_R = gd_mulfx(f_RY, f_RX); + + if ((src_offset_x[_k] <= 0) || (src_offset_y[_k] <= 0) || (src_offset_y[_k] >= src_h) || (src_offset_x[_k] >= src_w)) { + c = bgColor; + } else if ((src_offset_x[_k] <= 1) || (src_offset_y[_k] <= 1) || (src_offset_y[_k] >= (int)src_h - 1) || (src_offset_x[_k] >= (int)src_w - 1)) { + gdFixed f_127 = gd_itofx(127); + c = src->tpixels[src_offset_y[_k]][src_offset_x[_k]]; + c = c | (( (int) (gd_fxtof(gd_mulfx(f_R, f_127)) + 50.5f)) << 24); + c = _color_blend(bgColor, c); + } else { + c = src->tpixels[src_offset_y[_k]][src_offset_x[_k]]; + } + + f_rs = gd_itofx(gdTrueColorGetRed(c)); + f_gs = gd_itofx(gdTrueColorGetGreen(c)); + f_bs = gd_itofx(gdTrueColorGetBlue(c)); + f_as = gd_itofx(gdTrueColorGetAlpha(c)); + + f_red += gd_mulfx(f_rs, f_R); + f_green += gd_mulfx(f_gs, f_R); + f_blue += gd_mulfx(f_bs, f_R); + f_alpha += gd_mulfx(f_as, f_R); + } + } + + red = (unsigned char) CLAMP(gd_fxtoi(gd_mulfx(f_red, f_gama)), 0, 255); + green = (unsigned char) CLAMP(gd_fxtoi(gd_mulfx(f_green, f_gama)), 0, 255); + blue = (unsigned char) CLAMP(gd_fxtoi(gd_mulfx(f_blue, f_gama)), 0, 255); + alpha = (unsigned char) CLAMP(gd_fxtoi(gd_mulfx(f_alpha, f_gama)), 0, 127); + + dst->tpixels[dst_offset_y][dst_offset_x] = gdTrueColorAlpha(red, green, blue, alpha); + } else { + dst->tpixels[dst_offset_y][dst_offset_x] = bgColor; + } + dst_offset_x++; + } + + dst_offset_y++; + } + return dst; +} + +BGD_DECLARE(gdImagePtr) gdImageRotateInterpolated(const gdImagePtr src, const float angle, int bgcolor) +{ + /* round to two decimals and keep the 100x multiplication to use it in the common square angles + case later. Keep the two decimal precisions so smaller rotation steps can be done, useful for + slow animations, f.e. */ + const int angle_rounded = fmod((int) floorf(angle * 100), 360 * 100); + + if (bgcolor < 0) { + return NULL; + } + + /* 0 && 90 degrees multiple rotation, 0 rotation simply clones the return image and convert it + to truecolor, as we must return truecolor image. */ + switch (angle_rounded) { + case 0: { + gdImagePtr dst = gdImageClone(src); + + if (dst == NULL) { + return NULL; + } + if (dst->trueColor == 0) { + gdImagePaletteToTrueColor(dst); + } + return dst; + } + + case -2700: + case 9000: + return gdImageRotate90(src, 0); + + case -18000: + case 18000: + return gdImageRotate180(src, 0); + + case -9000: + case 27000: + return gdImageRotate270(src, 0); + } + + if (src == NULL || src->interpolation_id < 1 || src->interpolation_id > GD_METHOD_COUNT) { + return NULL; + } + + switch (src->interpolation_id) { + case GD_NEAREST_NEIGHBOUR: + return gdImageRotateNearestNeighbour(src, angle, bgcolor); + break; + + case GD_BILINEAR_FIXED: + return gdImageRotateBilinear(src, angle, bgcolor); + break; + + case GD_BICUBIC_FIXED: + return gdImageRotateBicubicFixed(src, angle, bgcolor); + break; + + default: + return gdImageRotateGeneric(src, angle, bgcolor); + } + return NULL; +} + +/** + * Title: Affine transformation + **/ + +/** + * Group: Transform + **/ + + static void gdImageClipRectangle(gdImagePtr im, gdRectPtr r) +{ + int c1x, c1y, c2x, c2y; + int x1,y1; + + gdImageGetClip(im, &c1x, &c1y, &c2x, &c2y); + x1 = r->x + r->width - 1; + y1 = r->y + r->height - 1; + r->x = CLAMP(r->x, c1x, c2x); + r->y = CLAMP(r->y, c1y, c2y); + r->width = CLAMP(x1, c1x, c2x) - r->x + 1; + r->height = CLAMP(y1, c1y, c2y) - r->y + 1; +} + +void gdDumpRect(const char *msg, gdRectPtr r) +{ + printf("%s (%i, %i) (%i, %i)\n", msg, r->x, r->y, r->width, r->height); +} + +/** + * Function: gdTransformAffineGetImage + * Applies an affine transformation to a region and return an image + * containing the complete transformation. + * + * Parameters: + * dst - Pointer to a gdImagePtr to store the created image, NULL when + * the creation or the transformation failed + * src - Source image + * src_area - rectangle defining the source region to transform + * dstY - Y position in the destination image + * affine - The desired affine transformation + * + * Returns: + * GD_TRUE if the affine is rectilinear or GD_FALSE + */ +BGD_DECLARE(int) gdTransformAffineGetImage(gdImagePtr *dst, + const gdImagePtr src, + gdRectPtr src_area, + const double affine[6]) +{ + int res; + double m[6]; + gdRect bbox; + gdRect area_full; + + if (src_area == NULL) { + area_full.x = 0; + area_full.y = 0; + area_full.width = gdImageSX(src); + area_full.height = gdImageSY(src); + src_area = &area_full; + } + + gdTransformAffineBoundingBox(src_area, affine, &bbox); + + *dst = gdImageCreateTrueColor(bbox.width, bbox.height); + if (*dst == NULL) { + return GD_FALSE; + } + (*dst)->saveAlphaFlag = 1; + + if (!src->trueColor) { + gdImagePaletteToTrueColor(src); + } + + /* Translate to dst origin (0,0) */ + gdAffineTranslate(m, -bbox.x, -bbox.y); + gdAffineConcat(m, affine, m); + + gdImageAlphaBlending(*dst, 0); + + res = gdTransformAffineCopy(*dst, + 0,0, + src, + src_area, + m); + + if (res != GD_TRUE) { + gdImageDestroy(*dst); + dst = NULL; + return GD_FALSE; + } else { + return GD_TRUE; + } +} + +/** + * Function: gdTransformAffineCopy + * Applies an affine transformation to a region and copy the result + * in a destination to the given position. + * + * Parameters: + * dst - Image to draw the transformed image + * src - Source image + * dstX - X position in the destination image + * dstY - Y position in the destination image + * src_area - Rectangular region to rotate in the src image + * + * Returns: + * GD_TRUE if the affine is rectilinear or GD_FALSE + */ +BGD_DECLARE(int) gdTransformAffineCopy(gdImagePtr dst, + int dst_x, int dst_y, + const gdImagePtr src, + gdRectPtr src_region, + const double affine[6]) +{ + int c1x,c1y,c2x,c2y; + int backclip = 0; + int backup_clipx1, backup_clipy1, backup_clipx2, backup_clipy2; + register int x, y, src_offset_x, src_offset_y; + double inv[6]; + int *dst_p; + gdPointF pt, src_pt; + gdRect bbox; + int end_x, end_y; + gdInterpolationMethod interpolation_id_bak = GD_DEFAULT; + + /* These methods use special implementations */ + if (src->interpolation_id == GD_BILINEAR_FIXED || src->interpolation_id == GD_BICUBIC_FIXED || src->interpolation_id == GD_NEAREST_NEIGHBOUR) { + interpolation_id_bak = src->interpolation_id; + + gdImageSetInterpolationMethod(src, GD_BICUBIC); + } + + + gdImageClipRectangle(src, src_region); + + if (src_region->x > 0 || src_region->y > 0 + || src_region->width < gdImageSX(src) + || src_region->height < gdImageSY(src)) { + backclip = 1; + + gdImageGetClip(src, &backup_clipx1, &backup_clipy1, + &backup_clipx2, &backup_clipy2); + + gdImageSetClip(src, src_region->x, src_region->y, + src_region->x + src_region->width - 1, + src_region->y + src_region->height - 1); + } + + if (!gdTransformAffineBoundingBox(src_region, affine, &bbox)) { + if (backclip) { + gdImageSetClip(src, backup_clipx1, backup_clipy1, + backup_clipx2, backup_clipy2); + } + gdImageSetInterpolationMethod(src, interpolation_id_bak); + return GD_FALSE; + } + + gdImageGetClip(dst, &c1x, &c1y, &c2x, &c2y); + + end_x = bbox.width + (int) fabs(bbox.x); + end_y = bbox.height + (int) fabs(bbox.y); + + /* Get inverse affine to let us work with destination -> source */ + gdAffineInvert(inv, affine); + + src_offset_x = src_region->x; + src_offset_y = src_region->y; + + if (dst->alphaBlendingFlag) { + for (y = bbox.y; y <= end_y; y++) { + pt.y = y + 0.5; + for (x = 0; x <= end_x; x++) { + pt.x = x + 0.5; + gdAffineApplyToPointF(&src_pt, &pt, inv); + gdImageSetPixel(dst, dst_x + x, dst_y + y, getPixelInterpolated(src, src_offset_x + src_pt.x, src_offset_y + src_pt.y, 0)); + } + } + } else { + for (y = 0; y <= end_y; y++) { + pt.y = y + 0.5 + bbox.y; + if ((dst_y + y) < 0 || ((dst_y + y) > gdImageSY(dst) -1)) { + continue; + } + dst_p = dst->tpixels[dst_y + y] + dst_x; + + for (x = 0; x <= end_x; x++) { + pt.x = x + 0.5 + bbox.x; + gdAffineApplyToPointF(&src_pt, &pt, inv); + + if ((dst_x + x) < 0 || (dst_x + x) > (gdImageSX(dst) - 1)) { + break; + } + *(dst_p++) = getPixelInterpolated(src, src_offset_x + src_pt.x, src_offset_y + src_pt.y, -1); + } + } + } + + /* Restore clip if required */ + if (backclip) { + gdImageSetClip(src, backup_clipx1, backup_clipy1, + backup_clipx2, backup_clipy2); + } + + gdImageSetInterpolationMethod(src, interpolation_id_bak); + return GD_TRUE; +} + +/** + * Function: gdTransformAffineBoundingBox + * Returns the bounding box of an affine transformation applied to a + * rectangular area <gdRect> + * + * Parameters: + * src - Rectangular source area for the affine transformation + * affine - the affine transformation + * bbox - the resulting bounding box + * + * Returns: + * GD_TRUE if the affine is rectilinear or GD_FALSE + */ +BGD_DECLARE(int) gdTransformAffineBoundingBox(gdRectPtr src, const double affine[6], gdRectPtr bbox) +{ + gdPointF extent[4], min, max, point; + int i; + + extent[0].x=0.0; + extent[0].y=0.0; + extent[1].x=(double) src->width; + extent[1].y=0.0; + extent[2].x=(double) src->width; + extent[2].y=(double) src->height; + extent[3].x=0.0; + extent[3].y=(double) src->height; + + for (i=0; i < 4; i++) { + point=extent[i]; + if (gdAffineApplyToPointF(&extent[i], &point, affine) != GD_TRUE) { + return GD_FALSE; + } + } + min=extent[0]; + max=extent[0]; + + for (i=1; i < 4; i++) { + if (min.x > extent[i].x) + min.x=extent[i].x; + if (min.y > extent[i].y) + min.y=extent[i].y; + if (max.x < extent[i].x) + max.x=extent[i].x; + if (max.y < extent[i].y) + max.y=extent[i].y; + } + bbox->x = (int) min.x; + bbox->y = (int) min.y; + bbox->width = (int) floor(max.x - min.x) - 1; + bbox->height = (int) floor(max.y - min.y); + return GD_TRUE; +} + +BGD_DECLARE(int) gdImageSetInterpolationMethod(gdImagePtr im, gdInterpolationMethod id) +{ + if (im == NULL || id < 0 || id > GD_METHOD_COUNT) { + return 0; + } + + switch (id) { + case GD_DEFAULT: + id = GD_BILINEAR_FIXED; + /* Optimized versions */ + case GD_BILINEAR_FIXED: + case GD_BICUBIC_FIXED: + case GD_NEAREST_NEIGHBOUR: + case GD_WEIGHTED4: + im->interpolation = NULL; + break; + + /* generic versions*/ + case GD_BELL: + im->interpolation = filter_bell; + break; + case GD_BESSEL: + im->interpolation = filter_bessel; + break; + case GD_BICUBIC: + im->interpolation = filter_bicubic; + break; + case GD_BLACKMAN: + im->interpolation = filter_blackman; + break; + case GD_BOX: + im->interpolation = filter_box; + break; + case GD_BSPLINE: + im->interpolation = filter_bspline; + break; + case GD_CATMULLROM: + im->interpolation = filter_catmullrom; + break; + case GD_GAUSSIAN: + im->interpolation = filter_gaussian; + break; + case GD_GENERALIZED_CUBIC: + im->interpolation = filter_generalized_cubic; + break; + case GD_HERMITE: + im->interpolation = filter_hermite; + break; + case GD_HAMMING: + im->interpolation = filter_hamming; + break; + case GD_HANNING: + im->interpolation = filter_hanning; + break; + case GD_MITCHELL: + im->interpolation = filter_mitchell; + break; + case GD_POWER: + im->interpolation = filter_power; + break; + case GD_QUADRATIC: + im->interpolation = filter_quadratic; + break; + case GD_SINC: + im->interpolation = filter_sinc; + break; + case GD_TRIANGLE: + im->interpolation = filter_triangle; + break; + + default: + return 0; + break; + } + im->interpolation_id = id; + return 1; +} + + +/* Return the interpolation mode set in 'im'. This is here so that + * the value can be read via a language or VM with an FFI but no + * (portable) way to extract the value from the struct. */ +BGD_DECLARE(gdInterpolationMethod) gdImageGetInterpolationMethod(gdImagePtr im) +{ + return im->interpolation_id; +} + +#ifdef _MSC_VER +# pragma optimize("", on) +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_io.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_io.c new file mode 100644 index 00000000000..03b83472120 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_io.c @@ -0,0 +1,228 @@ +/* + * io.c + * + * Implements the simple I/O 'helper' routines. + * + * Not really essential, but these routines were used extensively in GD, + * so they were moved here. They also make IOCtx calls look better... + * + * Written (or, at least, moved) 1999, Philip Warner. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include "gd.h" + +/* Use this for commenting out debug-print statements. */ +/* Just use the first '#define' to allow all the prints... */ +/*#define IO_DBG(s) (s) */ +#define IO_DBG(s) + +#define GD_IO_EOF_CHK(r) \ + if(r == EOF) { \ + return 0; \ + } + +/* + * Write out a word to the I/O context pointer + */ +void Putword(int w, gdIOCtx *ctx) +{ + unsigned char buf[2]; + buf[0] = w & 0xff; + buf[1] = (w / 256) & 0xff; + (ctx->putBuf)(ctx, (char *)buf, 2); +} + +void Putchar(int c, gdIOCtx *ctx) +{ + (ctx->putC)(ctx, c & 0xff); +} + +void gdPutC(const unsigned char c, gdIOCtx *ctx) +{ + (ctx->putC)(ctx, c); +} + +void gdPutWord (int w, gdIOCtx *ctx) +{ + IO_DBG(printf("Putting word...\n")); + (ctx->putC)(ctx, (unsigned char)(w >> 8)); + (ctx->putC)(ctx, (unsigned char)(w & 0xFF)); + IO_DBG(printf("put.\n")); +} + +void gdPutInt (int w, gdIOCtx *ctx) +{ + IO_DBG(printf("Putting int...\n")); + (ctx->putC)(ctx, (unsigned char) (w >> 24)); + (ctx->putC)(ctx, (unsigned char) ((w >> 16) & 0xFF)); + (ctx->putC)(ctx, (unsigned char) ((w >> 8) & 0xFF)); + (ctx->putC)(ctx, (unsigned char) (w & 0xFF)); + IO_DBG(printf("put.\n")); +} + +int gdGetC(gdIOCtx *ctx) +{ + return ((ctx->getC)(ctx)); +} + +int gdGetByte(int *result, gdIOCtx *ctx) +{ + int r; + + r = (ctx->getC)(ctx); + if(r == EOF) { + return 0; + } + + *result = r; + + return 1; +} + +int gdGetWord(int *result, gdIOCtx *ctx) +{ + int r; + + r = (ctx->getC)(ctx); + if(r == EOF) { + return 0; + } + + *result = r << 8; + + r = (ctx->getC)(ctx); + if(r == EOF) { + return 0; + } + + *result += r; + + return 1; +} + +int gdGetWordLSB(signed short int *result, gdIOCtx *ctx) +{ + int high = 0, low = 0; + low = (ctx->getC) (ctx); + if (low == EOF) { + return 0; + } + + high = (ctx->getC) (ctx); + if (high == EOF) { + return 0; + } + + if (result) { + *result = (high << 8) | low; + } + + return 1; +} + +int gdGetInt(int *result, gdIOCtx *ctx) +{ + int r; + + r = (ctx->getC)(ctx); + if(r == EOF) { + return 0; + } + + *result = r << 24; + + r = (ctx->getC)(ctx); + if(r == EOF) { + return 0; + } + + *result += r << 16; + + r = (ctx->getC)(ctx); + if(r == EOF) { + return 0; + } + + *result += r << 8; + + r = (ctx->getC)(ctx); + if(r == EOF) { + return 0; + } + + *result += r; + + return 1; +} + +int gdGetIntLSB(signed int *result, gdIOCtx *ctx) +{ + int c = 0; + unsigned int r = 0; + + c = (ctx->getC) (ctx); + if (c == EOF) { + return 0; + } + r |= (c << 24); + r >>= 8; + + c = (ctx->getC) (ctx); + if (c == EOF) { + return 0; + } + r |= (c << 24); + r >>= 8; + + c = (ctx->getC) (ctx); + if (c == EOF) { + return 0; + } + r |= (c << 24); + r >>= 8; + + c = (ctx->getC) (ctx); + if (c == EOF) { + return 0; + } + r |= (c << 24); + + if (result) { + *result = (signed int)r; + } + + return 1; +} + +int gdPutBuf(const void *buf, int size, gdIOCtx *ctx) +{ + IO_DBG(printf("Putting buf...\n")); + return (ctx->putBuf)(ctx, buf, size); + IO_DBG(printf("put.\n")); +} + +int gdGetBuf(void *buf, int size, gdIOCtx *ctx) +{ + return (ctx->getBuf)(ctx, buf, size); +} + +int gdSeek(gdIOCtx *ctx, const int pos) +{ + IO_DBG(printf("Seeking...\n")); + return ((ctx->seek)(ctx, pos)); + IO_DBG(printf("Done.\n")); +} + +long gdTell(gdIOCtx *ctx) +{ + IO_DBG(printf("Telling...\n")); + return ((ctx->tell)(ctx)); + IO_DBG(printf("told.\n")); +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_io.h b/Build/source/libs/gd/libgd-2.1.1/src/gd_io.h new file mode 100644 index 00000000000..1039d597dc8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_io.h @@ -0,0 +1,100 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef GD_IO_H +#define GD_IO_H 1 + +#include <stdio.h> + +#ifdef VMS +# define Putchar gdPutchar +#endif + +/* + Group: Types + + typedef: gdIOCtx + + gdIOCtx structures hold function pointers for doing image IO. + + Most of the gd functions that read and write files, such as + <gdImagePng> also have variants that accept a <gdIOCtx> structure; + see <gdImagePngCtx> and <gdImageCreateFromJpegCtx>. + + Those who wish to provide their own custom routines to read and + write images can populate a gdIOCtx structure with functions of + their own devising to to read and write data. For image reading, the + only mandatory functions are getC and getBuf, which must return the + number of characters actually read, or a negative value on error or + EOF. These functions must read the number of characters requested + unless at the end of the file. + + For image writing, the only mandatory functions are putC and putBuf, + which return the number of characters written; these functions must + write the number of characters requested except in the event of an + error. The seek and tell functions are only required in conjunction + with the gd2 file format, which supports quick loading of partial + images. The gd_free function will not be invoked when calling the + standard Ctx functions; it is an implementation convenience when + adding new data types to gd. For examples, see gd_png.c, gd_gd2.c, + gd_jpeg.c, etc., all of which rely on gdIOCtx to implement the + standard image read and write functions. + + > typedef struct gdIOCtx + > { + > int (*getC) (struct gdIOCtx *); + > int (*getBuf) (struct gdIOCtx *, void *, int wanted); + > + > void (*putC) (struct gdIOCtx *, int); + > int (*putBuf) (struct gdIOCtx *, const void *, int wanted); + > + > // seek must return 1 on SUCCESS, 0 on FAILURE. Unlike fseek! + > int (*seek) (struct gdIOCtx *, const int); + > long (*tell) (struct gdIOCtx *); + > + > void (*gd_free) (struct gdIOCtx *); + > } gdIOCtx; + + + + + */ +typedef struct gdIOCtx { + int (*getC)(struct gdIOCtx *); + int (*getBuf)(struct gdIOCtx *, void *, int); + void (*putC)(struct gdIOCtx *, int); + int (*putBuf)(struct gdIOCtx *, const void *, int); + /* seek must return 1 on SUCCESS, 0 on FAILURE. Unlike fseek! */ + int (*seek)(struct gdIOCtx *, const int); + long (*tell)(struct gdIOCtx *); + void (*gd_free)(struct gdIOCtx *); + void *data; +} gdIOCtx; + +typedef struct gdIOCtx *gdIOCtxPtr; + +void Putword(int w, gdIOCtx *ctx); +void Putchar(int c, gdIOCtx *ctx); + +void gdPutC(const unsigned char c, gdIOCtx *ctx); +int gdPutBuf(const void *, int, gdIOCtx *); +void gdPutWord(int w, gdIOCtx *ctx); +void gdPutInt(int w, gdIOCtx *ctx); + +int gdGetC(gdIOCtx *ctx); +int gdGetBuf(void *, int, gdIOCtx *); +int gdGetByte(int *result, gdIOCtx *ctx); +int gdGetWord(int *result, gdIOCtx *ctx); +int gdGetWordLSB(signed short int *result, gdIOCtx *ctx); +int gdGetInt(int *result, gdIOCtx *ctx); +int gdGetIntLSB(signed int *result, gdIOCtx *ctx); + +int gdSeek(gdIOCtx *ctx, const int offset); +long gdTell(gdIOCtx *ctx); + +#endif + +#ifdef __cplusplus +} +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_io_dp.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_io_dp.c new file mode 100644 index 00000000000..8dbcc62e2aa --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_io_dp.c @@ -0,0 +1,409 @@ +/* + * io_dp.c + * + * Implements the dynamic pointer interface. + * + * Based on GD.pm code by Lincoln Stein for interfacing to libgd. + * Added support for reading as well as support for 'tell' and 'seek'. + * + * As will all I/O modules, most functions are for local use only (called + * via function pointers in the I/O context). + * + * gdDPExtractData is the exception to this: it will return the pointer to + * the internal data, and reset the internal storage. + * + * Written/Modified 1999, Philip Warner. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" + +#define TRUE 1 +#define FALSE 0 + +/* this is used for creating images in main memory */ +typedef struct dpStruct { + void *data; + int logicalSize; + int realSize; + int dataGood; + int pos; + int freeOK; +} +dynamicPtr; + +typedef struct dpIOCtx { + gdIOCtx ctx; + dynamicPtr *dp; +} +dpIOCtx; + +typedef struct dpIOCtx *dpIOCtxPtr; + +/* these functions operate on in-memory dynamic pointers */ +static int allocDynamic(dynamicPtr *dp, int initialSize, void *data); +static int appendDynamic(dynamicPtr *dp, const void *src, int size); +static int gdReallocDynamic(dynamicPtr *dp, int required); +static int trimDynamic(dynamicPtr *dp); +static void gdFreeDynamicCtx(struct gdIOCtx *ctx); +static dynamicPtr *newDynamic(int initialSize, void *data, int freeOKFlag); + +static int dynamicPutbuf(struct gdIOCtx *, const void *, int); +static void dynamicPutchar(struct gdIOCtx *, int a); + +static int dynamicGetbuf(gdIOCtxPtr ctx, void *buf, int len); +static int dynamicGetchar(gdIOCtxPtr ctx); + +static int dynamicSeek(struct gdIOCtx *, const int); +static long dynamicTell(struct gdIOCtx *); + +/* return data as a dynamic pointer */ +BGD_DECLARE(gdIOCtx *) gdNewDynamicCtx(int initialSize, void *data) +{ + /* 2.0.23: Phil Moore: 'return' keyword was missing! */ + return gdNewDynamicCtxEx(initialSize, data, 1); +} + +BGD_DECLARE(gdIOCtx *) gdNewDynamicCtxEx(int initialSize, void *data, int freeOKFlag) +{ + dpIOCtx *ctx; + dynamicPtr *dp; + + ctx = (dpIOCtx *)gdMalloc(sizeof (dpIOCtx)); + if(ctx == NULL) { + return NULL; + } + + dp = newDynamic(initialSize, data, freeOKFlag); + if(!dp) { + gdFree (ctx); + return NULL; + }; + + ctx->dp = dp; + + ctx->ctx.getC = dynamicGetchar; + ctx->ctx.putC = dynamicPutchar; + + ctx->ctx.getBuf = dynamicGetbuf; + ctx->ctx.putBuf = dynamicPutbuf; + + ctx->ctx.seek = dynamicSeek; + ctx->ctx.tell = dynamicTell; + + ctx->ctx.gd_free = gdFreeDynamicCtx; + + return (gdIOCtx *)ctx; +} + +BGD_DECLARE(void *) gdDPExtractData (struct gdIOCtx *ctx, int *size) +{ + dynamicPtr *dp; + dpIOCtx *dctx; + void *data; + + dctx = (dpIOCtx *)ctx; + dp = dctx->dp; + + /* clean up the data block and return it */ + if(dp->dataGood) { + trimDynamic(dp); + *size = dp->logicalSize; + data = dp->data; + } else { + *size = 0; + data = NULL; + /* 2.0.21: never free memory we don't own */ + if((dp->data != NULL) && (dp->freeOK)) { + gdFree(dp->data); + } + } + + dp->data = NULL; + dp->realSize = 0; + dp->logicalSize = 0; + + return data; +} + +static void gdFreeDynamicCtx(struct gdIOCtx *ctx) +{ + dynamicPtr *dp; + dpIOCtx *dctx; + + dctx = (dpIOCtx *)ctx; + dp = dctx->dp; + + gdFree(ctx); + + /* clean up the data block and return it */ + /* 2.0.21: never free memory we don't own */ + if((dp->data != NULL) && (dp->freeOK)) { + gdFree(dp->data); + dp->data = NULL; + } + + dp->realSize = 0; + dp->logicalSize = 0; + + gdFree(dp); +} + +static long dynamicTell(struct gdIOCtx *ctx) +{ + dpIOCtx *dctx; + + dctx = (dpIOCtx *)ctx; + return (dctx->dp->pos); +} + +static int dynamicSeek(struct gdIOCtx *ctx, const int pos) +{ + int bytesNeeded; + dynamicPtr *dp; + dpIOCtx *dctx; + + dctx = (dpIOCtx *)ctx; + dp = dctx->dp; + + if(!dp->dataGood) { + return FALSE; + } + + bytesNeeded = pos; + if(bytesNeeded > dp->realSize) { + /* 2.0.21 */ + if(!dp->freeOK) { + return FALSE; + } + + if(overflow2(dp->realSize, 2)) { + return FALSE; + } + + if(!gdReallocDynamic(dp, dp->realSize * 2)) { + dp->dataGood = FALSE; + return FALSE; + } + } + + /* if we get here, we can be sure that we have enough bytes + * to copy safely */ + + /* Extend the logical size if we seek beyond EOF. */ + if(pos > dp->logicalSize) { + dp->logicalSize = pos; + }; + + dp->pos = pos; + + return TRUE; +} + +/* return data as a dynamic pointer */ +static dynamicPtr *newDynamic(int initialSize, void *data, int freeOKFlag) +{ + dynamicPtr *dp; + + dp = (dynamicPtr *) gdMalloc(sizeof (dynamicPtr)); + if(dp == NULL) { + return NULL; + } + + if(!allocDynamic(dp, initialSize, data)) { + gdFree(dp); + return NULL; + } + + dp->pos = 0; + dp->freeOK = freeOKFlag; + + return dp; +} + +static int dynamicPutbuf(struct gdIOCtx *ctx, const void *buf, int size) +{ + dpIOCtx *dctx; + dctx = (dpIOCtx *)ctx; + + appendDynamic(dctx->dp, buf, size); + + if(dctx->dp->dataGood) { + return size; + } else { + return -1; + }; +} + +static void dynamicPutchar(struct gdIOCtx *ctx, int a) +{ + unsigned char b; + dpIOCtxPtr dctx; + + b = a; + dctx = (dpIOCtxPtr) ctx; + + appendDynamic(dctx->dp, &b, 1); +} + +static int dynamicGetbuf(gdIOCtxPtr ctx, void *buf, int len) +{ + int rlen, remain; + dpIOCtxPtr dctx; + dynamicPtr *dp; + + dctx = (dpIOCtxPtr) ctx; + dp = dctx->dp; + + remain = dp->logicalSize - dp->pos; + if(remain >= len) { + rlen = len; + } else { + if(remain == 0) { + /* 2.0.34: EOF is incorrect. We use 0 for + * errors and EOF, just like fileGetbuf, + * which is a simple fread() wrapper. + * TBB. Original bug report: Daniel Cowgill. */ + return 0; /* NOT EOF */ + } + + rlen = remain; + } + + memcpy(buf, (void *) ((char *)dp->data + dp->pos), rlen); + dp->pos += rlen; + + return rlen; +} + +static int dynamicGetchar(gdIOCtxPtr ctx) +{ + unsigned char b; + int rv; + + rv = dynamicGetbuf(ctx, &b, 1); + + if(rv != 1) { + return EOF; + } else { + return b; /* (b & 0xff); */ + } +} + +/********************************************************************** + * InitDynamic - Return a dynamically resizable void* + **********************************************************************/ +static int allocDynamic(dynamicPtr *dp, int initialSize, void *data) +{ + if(data == NULL) { + dp->logicalSize = 0; + dp->dataGood = FALSE; + dp->data = gdMalloc(initialSize); + } else { + dp->logicalSize = initialSize; + dp->dataGood = TRUE; + dp->data = data; + } + + if(dp->data != NULL) { + dp->realSize = initialSize; + dp->dataGood = TRUE; + dp->pos = 0; + return TRUE; + } else { + dp->realSize = 0; + return FALSE; + } +} + +/* append bytes to the end of a dynamic pointer */ +static int appendDynamic(dynamicPtr * dp, const void *src, int size) +{ + int bytesNeeded; + char *tmp; + + if(!dp->dataGood) { + return FALSE; + } + + /* bytesNeeded = dp->logicalSize + size; */ + bytesNeeded = dp->pos + size; + + if(bytesNeeded > dp->realSize) { + /* 2.0.21 */ + if(!dp->freeOK) { + return FALSE; + } + + if(overflow2(dp->realSize, 2)) { + return FALSE; + } + + if(!gdReallocDynamic(dp, bytesNeeded * 2)) { + dp->dataGood = FALSE; + return FALSE; + } + } + + /* if we get here, we can be sure that we have enough bytes + * to copy safely */ + + /*printf("Mem OK Size: %d, Pos: %d\n", dp->realSize, dp->pos); */ + + tmp = (char *)dp->data; + memcpy ((void *)(tmp + (dp->pos)), src, size); + dp->pos += size; + + if(dp->pos > dp->logicalSize) { + dp->logicalSize = dp->pos; + }; + + return TRUE; +} + +/* grow (or shrink) dynamic pointer */ +static int gdReallocDynamic(dynamicPtr *dp, int required) +{ + void *newPtr; + + /* First try gdRealloc(). If that doesn't work, make a new + * memory block and copy. */ + if((newPtr = gdRealloc(dp->data, required))) { + dp->realSize = required; + dp->data = newPtr; + return TRUE; + } + + /* create a new pointer */ + newPtr = gdMalloc(required); + if(!newPtr) { + dp->dataGood = FALSE; + return FALSE; + } + + /* copy the old data into it */ + memcpy(newPtr, dp->data, dp->logicalSize); + gdFree(dp->data); + dp->data = newPtr; + + dp->realSize = required; + return TRUE; +} + +/* trim pointer so that its real and logical sizes match */ +static int trimDynamic(dynamicPtr *dp) +{ + /* 2.0.21: we don't reallocate memory we don't own */ + if(!dp->freeOK) { + return TRUE; + } + + return gdReallocDynamic(dp, dp->logicalSize); +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_io_file.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_io_file.c new file mode 100644 index 00000000000..d3893e4cea2 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_io_file.c @@ -0,0 +1,132 @@ +/* + * io_file.c + * + * Implements the file interface. + * + * As will all I/O modules, most functions are for local use only (called + * via function pointers in the I/O context). + * + * Most functions are just 'wrappers' for standard file functions. + * + * Written/Modified 1999, Philip Warner. + * + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +/* For platforms with incomplete ANSI defines. Fortunately, + * SEEK_SET is defined to be zero by the standard. */ + +#ifndef SEEK_SET +# define SEEK_SET 0 +#endif /* SEEK_SET */ + +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" + +/* this is used for creating images in main memory */ + +typedef struct fileIOCtx { + gdIOCtx ctx; + FILE *f; +} +fileIOCtx; + +gdIOCtx *newFileCtx(FILE *f); + +static int fileGetbuf(gdIOCtx *, void *, int); +static int filePutbuf(gdIOCtx *, const void *, int); +static void filePutchar(gdIOCtx *, int); +static int fileGetchar(gdIOCtx *ctx); + +static int fileSeek(struct gdIOCtx *, const int); +static long fileTell(struct gdIOCtx *); +static void gdFreeFileCtx(gdIOCtx *ctx); + +/* return data as a dynamic pointer */ +BGD_DECLARE(gdIOCtx *) gdNewFileCtx(FILE *f) +{ + fileIOCtx *ctx; + + if (f == NULL) return NULL; + ctx = (fileIOCtx *)gdMalloc(sizeof(fileIOCtx)); + if(ctx == NULL) { + return NULL; + } + + ctx->f = f; + + ctx->ctx.getC = fileGetchar; + ctx->ctx.putC = filePutchar; + + ctx->ctx.getBuf = fileGetbuf; + ctx->ctx.putBuf = filePutbuf; + + ctx->ctx.tell = fileTell; + ctx->ctx.seek = fileSeek; + + ctx->ctx.gd_free = gdFreeFileCtx; + + return (gdIOCtx *)ctx; +} + +static void gdFreeFileCtx(gdIOCtx *ctx) +{ + gdFree(ctx); +} + + +static int filePutbuf(gdIOCtx *ctx, const void *buf, int size) +{ + fileIOCtx *fctx; + fctx = (fileIOCtx *)ctx; + + return fwrite(buf, 1, size, fctx->f); +} + +static int fileGetbuf(gdIOCtx *ctx, void *buf, int size) +{ + fileIOCtx *fctx; + fctx = (fileIOCtx *)ctx; + + return (fread(buf, 1, size, fctx->f)); +} + +static void filePutchar(gdIOCtx *ctx, int a) +{ + unsigned char b; + fileIOCtx *fctx; + fctx = (fileIOCtx *)ctx; + + b = a; + + putc(b, fctx->f); +} + +static int fileGetchar(gdIOCtx *ctx) +{ + fileIOCtx *fctx; + fctx = (fileIOCtx *)ctx; + + return getc(fctx->f); +} + +static int fileSeek(struct gdIOCtx *ctx, const int pos) +{ + fileIOCtx *fctx; + fctx = (fileIOCtx *)ctx; + return (fseek(fctx->f, pos, SEEK_SET) == 0); +} + +static long fileTell (struct gdIOCtx *ctx) +{ + fileIOCtx *fctx; + fctx = (fileIOCtx *)ctx; + + return ftell(fctx->f); +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_io_ss.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_io_ss.c new file mode 100644 index 00000000000..a0cf3918f91 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_io_ss.c @@ -0,0 +1,142 @@ +/* + * io_ss.c + * + * Implements the Source/Sink interface. + * + * As will all I/O modules, most functions are for local use only (called + * via function pointers in the I/O context). + * + * The Source/Sink model is the primary 'user' interface for alternate data + * sources; the IOCtx interface is intended (at least in version 1.5) to be + * used internally until it settles down a bit. + * + * This module just layers the Source/Sink interface on top of the IOCtx; no + * support is provided for tell/seek, so GD2 writing is not possible, and + * retrieving parts of GD2 files is also not possible. + * + * A new SS context does not need to be created with both a Source and a Sink. + * + * Written/Modified 1999, Philip Warner. + * + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" + +/* this is used for creating images in main memory */ + +typedef struct ssIOCtx { + gdIOCtx ctx; + gdSourcePtr src; + gdSinkPtr snk; +} +ssIOCtx; + +typedef struct ssIOCtx *ssIOCtxPtr; + +static int sourceGetbuf(gdIOCtx *, void *, int); +static int sourceGetchar(gdIOCtx *ctx); +static int sinkPutbuf(gdIOCtx *ctx, const void *buf, int size); +static void sinkPutchar(gdIOCtx *ctx, int a); +static void gdFreeSsCtx(gdIOCtx *ctx); + +/* return data as a dynamic pointer */ +BGD_DECLARE(gdIOCtx *) gdNewSSCtx(gdSourcePtr src, gdSinkPtr snk) +{ + ssIOCtxPtr ctx; + + ctx = (ssIOCtxPtr)gdMalloc(sizeof (ssIOCtx)); + if (ctx == NULL) { + return NULL; + } + + ctx->src = src; + ctx->snk = snk; + + ctx->ctx.getC = sourceGetchar; + ctx->ctx.getBuf = sourceGetbuf; + + ctx->ctx.putC = sinkPutchar; + ctx->ctx.putBuf = sinkPutbuf; + + ctx->ctx.tell = NULL; + ctx->ctx.seek = NULL; + + ctx->ctx.gd_free = gdFreeSsCtx; + + return (gdIOCtx *)ctx; +} + +static void gdFreeSsCtx(gdIOCtx *ctx) +{ + gdFree(ctx); +} + +static int sourceGetbuf(gdIOCtx *ctx, void *buf, int size) +{ + ssIOCtx *lctx; + int res; + + lctx = (ssIOCtx *)ctx; + + res = ((lctx->src->source)(lctx->src->context, buf, size)); + + /* + * Translate the return values from the Source object: + * 0 is EOF, -1 is error + */ + + if (res == 0) { + return 0; + } else if (res < 0) { + return 0; + } else { + return res; + } +} + +static int sourceGetchar(gdIOCtx *ctx) +{ + int res; + unsigned char buf; + + res = sourceGetbuf(ctx, &buf, 1); + + if (res == 1) { + return buf; + } else { + return EOF; + } +} + +static int sinkPutbuf(gdIOCtx *ctx, const void *buf, int size) +{ + ssIOCtxPtr lctx; + int res; + + lctx = (ssIOCtx *)ctx; + + res = (lctx->snk->sink)(lctx->snk->context, buf, size); + + if (res <= 0) { + return 0; + } else { + return res; + } +} + +static void sinkPutchar(gdIOCtx *ctx, int a) +{ + unsigned char b; + + b = a; + + sinkPutbuf(ctx, &b, 1); +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_io_stream.cxx b/Build/source/libs/gd/libgd-2.1.1/src/gd_io_stream.cxx new file mode 100644 index 00000000000..28021afc1ae --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_io_stream.cxx @@ -0,0 +1,145 @@ +/* ***************************************************************************** +** $Id$ +** Initial file written and documented by: +** Kevin Shepherd <kshepherd@php.net> December 2007 +** of Scarlet Line http://www.scarletline.com/ +*******************************************************************************/ +/** \file gd_io_stream.cxx + \brief Implementation of the methods of the gdIOCtx std stream specialization. + + Implements the derived specializations of gdIOCtx. + These methods are not called by users of libgd, they + are internal implementation. + Note that half of the below methods are trivial stubs, + as an input stream has no need of output methods, and vice-versa. +*/ +#ifdef __cplusplus + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gd_io_stream.h" + +/** Read into buffer from stream + Return the number of bytes successfully read. + If an error occurs, or the end-of-file is reached, the return value + is a short byte count (or zero). +*/ +int istreamIOCtx::Getbuf (struct gdIOCtx * ctx, void * buf, int size) + { + stream_type * _str = ( (istreamIOCtx * ) ctx )->_M_stream; + _str->read((char * )buf, size); + return _str->gcount(); + } +/** Write from buffer to stream + Return the number of bytes successfully written. + If an error occurs, or the end-of-file is reached, the return value + is a short byte count (or zero). +*/ +int istreamIOCtx::Putbuf (struct gdIOCtx * , const void * , int ) + { + return 0; + } + +/** Reads the next character from stream and returns it as an + unsigned char cast to an int, or EOF on end of file or error. +*/ +int istreamIOCtx::Getchar (struct gdIOCtx * ctx) + { + stream_type * _str = ( (istreamIOCtx * ) ctx )->_M_stream; + return _str->get(); + } +/** Write the character to stream + Character is cast to unsigned char before writing +*/ +void istreamIOCtx::Putchar (struct gdIOCtx * , int ) + { + } + +/** Seek to position offset from the beginning of the stream + must return 1 on SUCCESS, 0 on FAILURE. Unlike fseek! +*/ +int istreamIOCtx::Seek (struct gdIOCtx * ctx, const int pos) + { + stream_type * _str = ( (istreamIOCtx * ) ctx )->_M_stream; + _str->seekg(pos); + return !_str->fail(); + } +/** Obtains the current value of the stream position. + Returns -1 on error. +*/ +long istreamIOCtx::Tell (struct gdIOCtx * ctx) + { + stream_type * _str = ( (istreamIOCtx * ) ctx )->_M_stream; + return _str->tellg(); + } +/** Deallocate the context +*/ +void istreamIOCtx::FreeCtx (struct gdIOCtx * ctx) + { + delete (istreamIOCtx * )ctx; + } + +/** Read into buffer from stream + Return the number of bytes successfully read. + If an error occurs, or the end-of-file is reached, the return value + is a short byte count (or zero). +*/ +int ostreamIOCtx::Getbuf (struct gdIOCtx * , void * , int ) + { + return 0; + } +/** Write from buffer to stream + Return the number of bytes successfully written. + If an error occurs, or the end-of-file is reached, the return value + is a short byte count (or zero). +*/ +int ostreamIOCtx::Putbuf (struct gdIOCtx * ctx, const void * buf, int size) + { + stream_type * _str = ( (ostreamIOCtx * ) ctx )->_M_stream; + _str->write((const char * )buf, size); + return _str->bad()?0:size; + } + +/** Reads the next character from stream and returns it as an + unsigned char cast to an int, or EOF on end of file or error. +*/ +int ostreamIOCtx::Getchar (struct gdIOCtx * ) + { + return EOF; + } +/** Write the character to stream + Character is cast to unsigned char before writing +*/ +void ostreamIOCtx::Putchar (struct gdIOCtx * ctx, int c) + { + stream_type * _str = ( (ostreamIOCtx * ) ctx )->_M_stream; + _str->put((char)c); + } + +/** Seek to position offset from the beginning of the stream + must return 1 on SUCCESS, 0 on FAILURE. Unlike fseek! +*/ +int ostreamIOCtx::Seek (struct gdIOCtx * ctx, const int pos) + { + stream_type * _str = ( (ostreamIOCtx * ) ctx )->_M_stream; + _str->seekp(pos); + return !_str->fail(); + } +/** Obtains the current value of the stream position. + Returns -1 on error. +*/ +long ostreamIOCtx::Tell (struct gdIOCtx * ctx) + { + stream_type * _str = ( (ostreamIOCtx * ) ctx )->_M_stream; + return _str->tellp(); + } +/** Deallocate the context +*/ +void ostreamIOCtx::FreeCtx (struct gdIOCtx * ctx) + { + delete (ostreamIOCtx * )ctx; + } + +#endif /* __cplusplus */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_io_stream.h b/Build/source/libs/gd/libgd-2.1.1/src/gd_io_stream.h new file mode 100644 index 00000000000..703548fec26 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_io_stream.h @@ -0,0 +1,126 @@ +/* ***************************************************************************** +** $Id$ +** Initial file written and documented by: +** Kevin Shepherd <kshepherd@php.net> December 2007 +** of Scarlet Line http://www.scarletline.com/ +*******************************************************************************/ +/** \file gd_io_stream.h + \brief C++ standard library iostream specializations of gdIOCtx. + + Note that all of the methods defined in this header are internal to the + libgd library, except for the constructors. + Only the constructors are needed by a user of the libgd API. + This file does not use or need gdpp.h, but if GD::Image is + used, then C++ coding becomes even simpler, and the classes below + become entirely hidden implementation details. + Example usage, convert png to gif: + #include <fstream> + #include "gd_io_stream.h" + std::ifstream in("image.png", std::ios_base::in | std::ios_base::binary ); + if (in.good()) + { + istreamIOCtx _in_ctx(in); + gdImagePtr im_in = gdImageCreateFromPngCtx ( & _in_ctx); + std::ofstream out("image.gif", std::ios_base::out | std::ios_base::binary ); + ostreamIOCtx _out_ctx(out); + gdImageGifCtx(im_in, & _out_ctx); + } + gdImageDestroy(im_in); +*/ +#ifdef __cplusplus +#ifndef _gd_io_stream_h +#define _gd_io_stream_h + +#include "gd.h" +#include <iostream> + +/** Standard library input stream specialization of gdIOCtx +*/ +class BGD_EXPORT_DATA_IMPL istreamIOCtx : public gdIOCtx +{ +public: + typedef std::istream stream_type; + /** Construct an instance of this input stream specialization, + given an input stream. + For example: + std::ifstream in("image.png", std::ios_base::in | std::ios_base::binary ); + istreamIOCtx in_ctx(in); + */ + istreamIOCtx(stream_type & __stream) { + init( & __stream); + } + + static int Getbuf (struct gdIOCtx * ctx, void * buf, int size); + static int Putbuf (struct gdIOCtx * , const void * , int ); + static void Putchar (struct gdIOCtx * , int ); + static int Getchar (struct gdIOCtx * ctx); + static int Seek (struct gdIOCtx * ctx, const int pos); + static long Tell (struct gdIOCtx * ctx); + static void FreeCtx (struct gdIOCtx * ctx); + + void init(stream_type * __stream) { + getC = Getchar; + putC = Putchar; + getBuf = Getbuf; + putBuf = Putbuf; + tell = Tell; + seek = Seek; + gd_free = FreeCtx; + _M_stream = __stream; + } +private: + stream_type * _M_stream; +}; +/** Allocate a new instance of the class +*/ +inline gdIOCtx * gdNewIstreamCtx (std::istream * __stream) +{ + return new istreamIOCtx(* __stream); +} + +/** Standard library output stream specialization of gdIOCtx +*/ +class BGD_EXPORT_DATA_IMPL ostreamIOCtx : public gdIOCtx +{ +public: + typedef std::ostream stream_type; + /** Construct an instance of this output stream specialization, + given an output stream. + For example: + std::ofstream out("image.gif", std::ios_base::out | std::ios_base::binary ); + ostreamIOCtx out_ctx(out); + */ + ostreamIOCtx(stream_type & __stream) { + init( & __stream); + } + + static int Getbuf (struct gdIOCtx * , void * , int ); + static int Putbuf (struct gdIOCtx * ctx, const void * buf, int size); + static int Getchar (struct gdIOCtx * ); + static void Putchar (struct gdIOCtx * ctx, int a); + static int Seek (struct gdIOCtx * ctx, const int pos); + static long Tell (struct gdIOCtx * ctx); + static void FreeCtx (struct gdIOCtx * ctx); + + void init(stream_type * __stream) { + getC = Getchar; + putC = Putchar; + getBuf = Getbuf; + putBuf = Putbuf; + tell = Tell; + seek = Seek; + gd_free = FreeCtx; + _M_stream = __stream; + } +private: + stream_type * _M_stream; +}; +/** Allocate a new instance of the class +*/ +inline gdIOCtx * gdNewOstreamCtx (std::ostream * __stream) +{ + return new ostreamIOCtx(* __stream); +} + +#endif /* _gd_io_stream_h */ +#endif /* __cplusplus */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_jpeg.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_jpeg.c new file mode 100644 index 00000000000..925b417fac3 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_jpeg.c @@ -0,0 +1,1202 @@ +/* + * gd_jpeg.c: Read and write JPEG (JFIF) format image files using the + * gd graphics library (http://www.libgd.org). + * + * This software is based in part on the work of the Independent JPEG + * Group. For more information on the IJG JPEG software (and JPEG + * documentation, etc.), see ftp://ftp.uu.net/graphics/jpeg/. + * + * NOTE: IJG 12-bit JSAMPLE (BITS_IN_JSAMPLE == 12) mode is not + * supported at all on read in gd 2.0, and is not supported on write + * except for palette images, which is sort of pointless (TBB). Even that + * has never been tested according to DB. + * + * Copyright 2000 Doug Becker, mailto:thebeckers@home.com + * + * Modification 4/18/00 TBB: JPEG_DEBUG rather than just DEBUG, + * so VC++ builds don't spew to standard output, causing + * major CGI brain damage + * + * 2.0.10: more efficient gdImageCreateFromJpegCtx, thanks to + * Christian Aberger + */ + + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <stdlib.h> +#include <setjmp.h> +#include <limits.h> +#include <string.h> + +#include "gd.h" +#include "gd_errors.h" +/* TBB: move this up so include files are not brought in */ +/* JCE: arrange HAVE_LIBJPEG so that it can be set in gd.h */ +#ifdef HAVE_LIBJPEG +#include "gdhelpers.h" + +#if defined(_WIN32) && defined(__MINGW32__) +# define HAVE_BOOLEAN +#endif + +/* JCE undef two symbols that we don't need anymore but which are + may be defined in config.h from ./configure but which are + redefined incompatibly in jpeglib.h */ +#undef HAVE_STDDEF_H +#undef HAVE_STDLIB_H + +/* 1.8.1: remove dependency on jinclude.h */ +#include "jpeglib.h" +#include "jerror.h" + +static const char *const GD_JPEG_VERSION = "1.0"; + +typedef struct _jmpbuf_wrapper { + jmp_buf jmpbuf; + int ignore_warning; +} +jmpbuf_wrapper; + +static void jpeg_emit_message(j_common_ptr jpeg_info, int level) +{ + char message[JMSG_LENGTH_MAX]; + jmpbuf_wrapper *jmpbufw; + int ignore_warning = 0; + + jmpbufw = (jmpbuf_wrapper *) jpeg_info->client_data; + + if (jmpbufw != 0) { + ignore_warning = jmpbufw->ignore_warning; + } + + (jpeg_info->err->format_message)(jpeg_info,message); + + /* It is a warning message */ + if (level < 0) { + /* display only the 1st warning, as would do a default libjpeg + * unless strace_level >= 3 + */ + if ((jpeg_info->err->num_warnings == 0) || (jpeg_info->err->trace_level >= 3)) { + if (!ignore_warning) { + gd_error("gd-jpeg, libjpeg: recoverable error: %s\n", message); + } + } + + jpeg_info->err->num_warnings++; + } else { + /* strace msg, Show it if trace_level >= level. */ + if (jpeg_info->err->trace_level >= level) { + if (!ignore_warning) { + gd_error("gd-jpeg, libjpeg: strace message: %s\n", message); + } + } + } +} + +/* Called by the IJG JPEG library upon encountering a fatal error */ +static void fatal_jpeg_error(j_common_ptr cinfo) +{ + jmpbuf_wrapper *jmpbufw; + char buffer[JMSG_LENGTH_MAX]; + + (*cinfo->err->format_message)(cinfo, buffer); + gd_error_ex(GD_ERROR, "gd-jpeg: JPEG library reports unrecoverable error: %s", buffer); + + jmpbufw = (jmpbuf_wrapper *)cinfo->client_data; + jpeg_destroy(cinfo); + + if(jmpbufw != 0) { + longjmp(jmpbufw->jmpbuf, 1); + gd_error_ex(GD_ERROR, "gd-jpeg: EXTREMELY fatal error: longjmp returned control; terminating\n"); + } else { + gd_error_ex(GD_ERROR, "gd-jpeg: EXTREMELY fatal error: jmpbuf unrecoverable; terminating\n"); + } + + exit(99); +} + +/* + * Write IM to OUTFILE as a JFIF-formatted JPEG image, using quality + * QUALITY. If QUALITY is in the range 0-100, increasing values + * represent higher quality but also larger image size. If QUALITY is + * negative, the IJG JPEG library's default quality is used (which + * should be near optimal for many applications). See the IJG JPEG + * library documentation for more details. + */ + + +/* + Function: gdImageJpeg + + <gdImageJpeg> outputs the specified image to the specified file in + JPEG format. The file must be open for writing. Under MSDOS and + all versions of Windows, it is important to use "wb" as opposed to + simply "w" as the mode when opening the file, and under Unix there + is no penalty for doing so. <gdImageJpeg> does not close the file; + your code must do so. + + If _quality_ is negative, the default IJG JPEG quality value (which + should yield a good general quality / size tradeoff for most + situations) is used. Otherwise, for practical purposes, _quality_ + should be a value in the range 0-95, higher quality values usually + implying both higher quality and larger image sizes. + + If you have set image interlacing using <gdImageInterlace>, this + function will interpret that to mean you wish to output a + progressive JPEG. Some programs (e.g., Web browsers) can display + progressive JPEGs incrementally; this can be useful when browsing + over a relatively slow communications link, for + example. Progressive JPEGs can also be slightly smaller than + sequential (non-progressive) JPEGs. + + Variants: + + <gdImageJpegCtx> stores the image using a <gdIOCtx> struct. + + <gdImageJpegPtr> stores the image to RAM. + + Parameters: + + im - The image to save + outFile - The FILE pointer to write to. + quality - Compression quality (0-95, 0 means use the default). + + Returns: + + Nothing. + + Example: + + > gdImagePtr im; + > int black, white; + > FILE *out; + > // Create the image + > im = gdImageCreate(100, 100); + > // Allocate background + > white = gdImageColorAllocate(im, 255, 255, 255); + > // Allocate drawing color + > black = gdImageColorAllocate(im, 0, 0, 0); + > // Draw rectangle + > gdImageRectangle(im, 0, 0, 99, 99, black); + > // Open output file in binary mode + > out = fopen("rect.jpg", "wb"); + > // Write JPEG using default quality + > gdImageJpeg(im, out, -1); + > // Close file + > fclose(out); + > // Destroy image + > gdImageDestroy(im); + +*/ + +BGD_DECLARE(void) gdImageJpeg(gdImagePtr im, FILE *outFile, int quality) +{ + gdIOCtx *out = gdNewFileCtx(outFile); + if (out == NULL) return; + gdImageJpegCtx(im, out, quality); + out->gd_free(out); +} + +/* + Function: gdImageJpegPtr + + Identical to <gdImageJpeg> except that it returns a pointer to a + memory area with the JPEG data. This memory must be freed by the + caller when it is no longer needed. + + The caller *must* invoke <gdFree>, not free(). This is because it + is not guaranteed that libgd will use the same implementation of + malloc, free, etc. as your proggram. + + The 'size' parameter receives the total size of the block of + memory. + + Parameters: + + im - The image to write + size - Output: the size of the resulting image. + quality - Compression quality. + + Returns: + + A pointer to the JPEG data or NULL if an error occurred. + +*/ +BGD_DECLARE(void *) gdImageJpegPtr(gdImagePtr im, int *size, int quality) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx(2048, NULL); + if (out == NULL) return NULL; + gdImageJpegCtx(im, out, quality); + rv = gdDPExtractData(out, size); + out->gd_free(out); + return rv; +} + +void jpeg_gdIOCtx_dest(j_compress_ptr cinfo, gdIOCtx *outfile); + +/* + Function: gdImageJpegCtx + + Write the image as JPEG data via a <gdIOCtx>. See <gdImageJpeg> + for more details. + + Parameters: + + im - The image to write. + outfile - The output sink. + quality - Image quality. + +*/ +BGD_DECLARE(void) gdImageJpegCtx(gdImagePtr im, gdIOCtx *outfile, int quality) +{ + struct jpeg_compress_struct cinfo; + struct jpeg_error_mgr jerr; + int i, j, jidx; + /* volatile so we can gdFree it on return from longjmp */ + volatile JSAMPROW row = 0; + JSAMPROW rowptr[1]; + jmpbuf_wrapper jmpbufw; + JDIMENSION nlines; + char comment[255]; + +#ifdef JPEG_DEBUG + gd_error_ex(GD_DEBUG, "gd-jpeg: gd JPEG version %s\n", GD_JPEG_VERSION); + gd_error_ex(GD_DEBUG, "gd-jpeg: JPEG library version %d, %d-bit sample values\n", JPEG_LIB_VERSION, BITS_IN_JSAMPLE); + if (!im->trueColor) { + for(i = 0; i < im->colorsTotal; i++) { + if(!im->open[i]) { + gd_error_ex(GD_DEBUG, "gd-jpeg: gd colormap index %d: (%d, %d, %d)\n", i, im->red[i], im->green[i], im->blue[i]); + } + } + } +#endif /* JPEG_DEBUG */ + + memset(&cinfo, 0, sizeof(cinfo)); + memset(&jerr, 0, sizeof(jerr)); + + cinfo.err = jpeg_std_error(&jerr); + cinfo.client_data = &jmpbufw; + + if(setjmp(jmpbufw.jmpbuf) != 0) { + /* we're here courtesy of longjmp */ + if(row) { + gdFree(row); + } + return; + } + + cinfo.err->emit_message = jpeg_emit_message; + cinfo.err->error_exit = fatal_jpeg_error; + + jpeg_create_compress(&cinfo); + + cinfo.image_width = im->sx; + cinfo.image_height = im->sy; + cinfo.input_components = 3; /* # of color components per pixel */ + cinfo.in_color_space = JCS_RGB; /* colorspace of input image */ + + jpeg_set_defaults(&cinfo); + + cinfo.density_unit = 1; + cinfo.X_density = im->res_x; + cinfo.Y_density = im->res_y; + + if(quality >= 0) { + jpeg_set_quality(&cinfo, quality, TRUE); + } + + /* If user requests interlace, translate that to progressive JPEG */ + if(gdImageGetInterlaced(im)) { +#ifdef JPEG_DEBUG + gd_error_ex(GD_DEBUG, "gd-jpeg: interlace set, outputting progressive JPEG image\n"); +#endif + jpeg_simple_progression(&cinfo); + } + + jpeg_gdIOCtx_dest(&cinfo, outfile); + + row = (JSAMPROW)gdCalloc(1, cinfo.image_width * cinfo.input_components * sizeof(JSAMPLE)); + if(row == 0) { + gd_error("gd-jpeg: error: unable to allocate JPEG row structure: gdCalloc returns NULL\n"); + jpeg_destroy_compress(&cinfo); + return; + } + + rowptr[0] = row; + + jpeg_start_compress(&cinfo, TRUE); + + sprintf(comment, "CREATOR: gd-jpeg v%s (using IJG JPEG v%d),", GD_JPEG_VERSION, JPEG_LIB_VERSION); + + if(quality >= 0) { + sprintf (comment + strlen(comment), " quality = %d\n", quality); + } else { + strcat(comment + strlen(comment), " default quality\n"); + } + + jpeg_write_marker(&cinfo, JPEG_COM, (unsigned char *) comment, (unsigned int)strlen(comment)); + + if(im->trueColor) { +#if BITS_IN_JSAMPLE == 12 + gd_error( + "gd-jpeg: error: jpeg library was compiled for 12-bit\n" + "precision. This is mostly useless, because JPEGs on the web are\n" + "8-bit and such versions of the jpeg library won't read or write\n" + "them. GD doesn't support these unusual images. Edit your\n" + "jmorecfg.h file to specify the correct precision and completely\n" + "'make clean' and 'make install' libjpeg again. Sorry.\n" + ); + goto error; +#endif /* BITS_IN_JSAMPLE == 12 */ + for(i = 0; i < im->sy; i++) { + for(jidx = 0, j = 0; j < im->sx; j++) { + int val = im->tpixels[i][j]; + row[jidx++] = gdTrueColorGetRed(val); + row[jidx++] = gdTrueColorGetGreen(val); + row[jidx++] = gdTrueColorGetBlue(val); + } + + nlines = jpeg_write_scanlines(&cinfo, rowptr, 1); + + if(nlines != 1) { + gd_error("gd_jpeg: warning: jpeg_write_scanlines returns %u -- expected 1\n", nlines); + } + } + } else { + for(i = 0; i < im->sy; i++) { + for(jidx = 0, j = 0; j < im->sx; j++) { + int idx = im->pixels[i][j]; + + /* + * NB: Although gd RGB values are ints, their max value is + * 255 (see the documentation for gdImageColorAllocate()) + * -- perfect for 8-bit JPEG encoding (which is the norm) + */ +#if BITS_IN_JSAMPLE == 8 + row[jidx++] = im->red[idx]; + row[jidx++] = im->green[idx]; + row[jidx++] = im->blue[idx]; +#elif BITS_IN_JSAMPLE == 12 + row[jidx++] = im->red[idx] << 4; + row[jidx++] = im->green[idx] << 4; + row[jidx++] = im->blue[idx] << 4; +#else +#error IJG JPEG library BITS_IN_JSAMPLE value must be 8 or 12 +#endif + } + + nlines = jpeg_write_scanlines(&cinfo, rowptr, 1); + if(nlines != 1) { + gd_error("gd_jpeg: warning: jpeg_write_scanlines" + " returns %u -- expected 1\n", nlines); + } + } + } + + jpeg_finish_compress(&cinfo); + jpeg_destroy_compress(&cinfo); + gdFree(row); +} + + + + +/* + Function: gdImageCreateFromJpeg + + See <gdImageCreateFromJpegEx>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpeg(FILE *inFile) +{ + return gdImageCreateFromJpegEx(inFile, 1); +} + + +/* + Function: gdImageCreateFromJpegEx + + <gdImageCreateFromJpegEx> is called to load truecolor images from + JPEG format files. Invoke <gdImageCreateFromJpegEx> with an + already opened pointer to a file containing the desired + image. <gdImageCreateFromJpegEx> returns a <gdImagePtr> to the new + truecolor image, or NULL if unable to load the image (most often + because the file is corrupt or does not contain a JPEG + image). <gdImageCreateFromJpegEx> does not close the file. + + You can inspect the sx and sy members of the image to determine + its size. The image must eventually be destroyed using + <gdImageDestroy>. + + *The returned image is always a truecolor image.* + + Variants: + + <gdImageCreateFromJpegPtrEx> creates an image from JPEG data + already in memory. + + <gdImageCreateFromJpegCtxEx> reads its data via the function + pointers in a <gdIOCtx> structure. + + <gdImageCreateFromJpeg>, <gdImageCreateFromJpegPtr> and + <gdImageCreateFromJpegCtx> are equivalent to calling their + _Ex_-named counterparts with an ignore_warning set to 1 + (i.e. TRUE). + + Parameters: + + infile - The input FILE pointer. + ignore_warning - Flag. If true, ignores recoverable warnings. + + Returns: + + A pointer to the new *truecolor* image. This will need to be + destroyed with <gdImageDestroy> once it is no longer needed. + + On error, returns NULL. + + Example: + + > gdImagePtr im; + > FILE *in; + > in = fopen("myjpeg.jpg", "rb"); + > im = gdImageCreateFromJpegEx(in, GD_TRUE); + > fclose(in); + > // ... Use the image ... + > gdImageDestroy(im); + +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegEx(FILE *inFile, int ignore_warning) +{ + gdImagePtr im; + gdIOCtx *in = gdNewFileCtx(inFile); + if (in == NULL) return NULL; + im = gdImageCreateFromJpegCtxEx(in, ignore_warning); + in->gd_free(in); + return im; +} + +/* + Function: gdImageCreateFromJpegPtr + + Parameters: + + size - size of JPEG data in bytes. + data - pointer to JPEG data. + + See <gdImageCreateFromJpegEx>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegPtr(int size, void *data) +{ + return gdImageCreateFromJpegPtrEx(size, data, 1); +} + +/* + Function: gdImageCreateFromJpegPtrEx + + Parameters: + + size - size of JPEG data in bytes. + data - pointer to JPEG data. + ignore_warning - if true, ignore recoverable warnings + + See <gdImageCreateFromJpegEx>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegPtrEx(int size, void *data, int ignore_warning) +{ + gdImagePtr im; + gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); + if(!in) { + return 0; + } + im = gdImageCreateFromJpegCtxEx(in, ignore_warning); + in->gd_free(in); + return im; +} + +void jpeg_gdIOCtx_src(j_decompress_ptr cinfo, gdIOCtx *infile); + +static int CMYKToRGB(int c, int m, int y, int k, int inverted); + +/* + Function: gdImageCreateFromJpegCtx + + See <gdImageCreateFromJpeg>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegCtx(gdIOCtx *infile) +{ + return gdImageCreateFromJpegCtxEx(infile, 1); +} + +/* + Function: gdImageCreateFromJpegCtxEx + + See <gdImageCreateFromJpeg>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromJpegCtxEx(gdIOCtx *infile, int ignore_warning) +{ + struct jpeg_decompress_struct cinfo; + struct jpeg_error_mgr jerr; + jmpbuf_wrapper jmpbufw; + /* volatile so we can gdFree them after longjmp */ + volatile JSAMPROW row = 0; + volatile gdImagePtr im = 0; + JSAMPROW rowptr[1]; + JDIMENSION i, j; + int retval; + JDIMENSION nrows; + int channels = 3; + int inverted = 0; + +#ifdef JPEG_DEBUG + gd_error_ex(GD_DEBUG, "gd-jpeg: gd JPEG version %s\n", GD_JPEG_VERSION); + gd_error_ex(GD_DEBUG, "gd-jpeg: JPEG library version %d, %d-bit sample values\n", JPEG_LIB_VERSION, BITS_IN_JSAMPLE); + gd_error_ex(GD_DEBUG, "sizeof: %d\n", sizeof(struct jpeg_decompress_struct)); +#endif + + memset(&cinfo, 0, sizeof(cinfo)); + memset(&jerr, 0, sizeof(jerr)); + + jmpbufw.ignore_warning = ignore_warning; + + cinfo.err = jpeg_std_error(&jerr); + cinfo.client_data = &jmpbufw; + + cinfo.err->emit_message = jpeg_emit_message; + + if(setjmp(jmpbufw.jmpbuf) != 0) { + /* we're here courtesy of longjmp */ + if(row) { + gdFree(row); + } + if(im) { + gdImageDestroy(im); + } + return 0; + } + + cinfo.err->error_exit = fatal_jpeg_error; + + jpeg_create_decompress(&cinfo); + + jpeg_gdIOCtx_src(&cinfo, infile); + + /* 2.0.22: save the APP14 marker to check for Adobe Photoshop CMYK + * files with inverted components. + */ + jpeg_save_markers(&cinfo, JPEG_APP0 + 14, 256); + + retval = jpeg_read_header(&cinfo, TRUE); + if(retval != JPEG_HEADER_OK) { + gd_error("gd-jpeg: warning: jpeg_read_header returns" + " %d, expected %d\n", retval, JPEG_HEADER_OK); + } + + if(cinfo.image_height > INT_MAX) { + gd_error("gd-jpeg: warning: JPEG image height (%u) is" + " greater than INT_MAX (%d) (and thus greater than" + " gd can handle)", cinfo.image_height, INT_MAX); + } + + if(cinfo.image_width > INT_MAX) { + gd_error("gd-jpeg: warning: JPEG image width (%u) is" + " greater than INT_MAX (%d) (and thus greater than" + " gd can handle)\n", cinfo.image_width, INT_MAX); + } + + im = gdImageCreateTrueColor((int)cinfo.image_width, (int)cinfo.image_height); + if(im == 0) { + gd_error("gd-jpeg error: cannot allocate gdImage struct\n"); + goto error; + } + + /* check if the resolution is specified */ + switch (cinfo.density_unit) { + case 1: + im->res_x = cinfo.X_density; + im->res_y = cinfo.Y_density; + break; + case 2: + im->res_x = DPCM2DPI(cinfo.X_density); + im->res_y = DPCM2DPI(cinfo.Y_density); + break; + } + + /* 2.0.22: very basic support for reading CMYK colorspace files. Nice for + * thumbnails but there's no support for fussy adjustment of the + * assumed properties of inks and paper. + */ + if((cinfo.jpeg_color_space == JCS_CMYK) || (cinfo.jpeg_color_space == JCS_YCCK)) { + cinfo.out_color_space = JCS_CMYK; + } else { + cinfo.out_color_space = JCS_RGB; + } + + if(jpeg_start_decompress(&cinfo) != TRUE) { + gd_error("gd-jpeg: warning: jpeg_start_decompress" + " reports suspended data source\n"); + } + +#ifdef JPEG_DEBUG + gd_error_ex(GD_DEBUG, "gd-jpeg: JPEG image information:"); + if(cinfo.saw_JFIF_marker) { + gd_error_ex(GD_DEBUG, " JFIF version %d.%.2d", (int)cinfo.JFIF_major_version, (int)cinfo.JFIF_minor_version); + } else if(cinfo.saw_Adobe_marker) { + gd_error_ex(GD_DEBUG, " Adobe format"); + } else { + gd_error_ex(GD_DEBUG, " UNKNOWN format"); + } + + gd_error_ex(GD_DEBUG, " %ux%u (raw) / %ux%u (scaled) %d-bit", cinfo.image_width, + cinfo.image_height, cinfo.output_width, + cinfo.output_height, cinfo.data_precision + ); + gd_error_ex(GD_DEBUG, " %s", (cinfo.progressive_mode ? "progressive" : "baseline")); + gd_error_ex(GD_DEBUG, " image, %d quantized colors, ", cinfo.actual_number_of_colors); + + switch(cinfo.jpeg_color_space) { + case JCS_GRAYSCALE: + gd_error_ex(GD_DEBUG, "grayscale"); + break; + + case JCS_RGB: + gd_error_ex(GD_DEBUG, "RGB"); + break; + + case JCS_YCbCr: + gd_error_ex(GD_DEBUG, "YCbCr (a.k.a. YUV)"); + break; + + case JCS_CMYK: + gd_error_ex(GD_DEBUG, "CMYK"); + break; + + case JCS_YCCK: + gd_error_ex(GD_DEBUG, "YCbCrK"); + break; + + default: + gd_error_ex(GD_DEBUG, "UNKNOWN (value: %d)", (int)cinfo.jpeg_color_space); + break; + } + + gd_error_ex(GD_DEBUG, " colorspace\n"); + fflush(stdout); +#endif /* JPEG_DEBUG */ + + /* REMOVED by TBB 2/12/01. This field of the structure is + * documented as private, and sure enough it's gone in the + * latest libjpeg, replaced by something else. Unfortunately + * there is still no right way to find out if the file was + * progressive or not; just declare your intent before you + * write one by calling gdImageInterlace(im, 1) yourself. + * After all, we're not really supposed to rework JPEGs and + * write them out again anyway. Lossy compression, remember? */ +#if 0 + gdImageInterlace (im, cinfo.progressive_mode != 0); +#endif + if(cinfo.out_color_space == JCS_RGB) { + if(cinfo.output_components != 3) { + gd_error("gd-jpeg: error: JPEG color quantization" + " request resulted in output_components == %d" + " (expected 3 for RGB)\n", cinfo.output_components); + goto error; + } + channels = 3; + } else if(cinfo.out_color_space == JCS_CMYK) { + jpeg_saved_marker_ptr marker; + if(cinfo.output_components != 4) { + gd_error("gd-jpeg: error: JPEG color quantization" + " request resulted in output_components == %d" + " (expected 4 for CMYK)\n", cinfo.output_components); + goto error; + } + channels = 4; + + marker = cinfo.marker_list; + while(marker) { + if( (marker->marker == (JPEG_APP0 + 14)) && + (marker->data_length >= 12) && + (!strncmp((const char *)marker->data, "Adobe", 5))) { + inverted = 1; + break; + } + marker = marker->next; + } + } else { + gd_error("gd-jpeg: error: unexpected colorspace\n"); + goto error; + } +#if BITS_IN_JSAMPLE == 12 + gd_error_ex(GD_ERROR, + "gd-jpeg: error: jpeg library was compiled for 12-bit\n" + "precision. This is mostly useless, because JPEGs on the web are\n" + "8-bit and such versions of the jpeg library won't read or write\n" + "them. GD doesn't support these unusual images. Edit your\n" + "jmorecfg.h file to specify the correct precision and completely\n" + "'make clean' and 'make install' libjpeg again. Sorry.\n"); + goto error; +#endif /* BITS_IN_JSAMPLE == 12 */ + + row = gdCalloc(cinfo.output_width *channels, sizeof(JSAMPLE)); + if(row == 0) { + gd_error("gd-jpeg: error: unable to allocate row for" + " JPEG scanline: gdCalloc returns NULL\n"); + goto error; + } + rowptr[0] = row; + if(cinfo.out_color_space == JCS_CMYK) { + for(i = 0; i < cinfo.output_height; i++) { + register JSAMPROW currow = row; + register int *tpix = im->tpixels[i]; + nrows = jpeg_read_scanlines(&cinfo, rowptr, 1); + if(nrows != 1) { + gd_error("gd-jpeg: error: jpeg_read_scanlines" + " returns %u, expected 1\n", nrows); + goto error; + } + for(j = 0; j < cinfo.output_width; j++, currow += 4, tpix++) { + *tpix = CMYKToRGB(currow[0], currow[1], currow[2], currow[3], inverted); + } + } + } else { + for(i = 0; i < cinfo.output_height; i++) { + register JSAMPROW currow = row; + register int *tpix = im->tpixels[i]; + nrows = jpeg_read_scanlines(&cinfo, rowptr, 1); + if(nrows != 1) { + gd_error("gd-jpeg: error: jpeg_read_scanlines" + " returns %u, expected 1\n", nrows); + goto error; + } + for(j = 0; j < cinfo.output_width; j++, currow += 3, tpix++) { + *tpix = gdTrueColor(currow[0], currow[1], currow[2]); + } + } + } + + if(jpeg_finish_decompress (&cinfo) != TRUE) { + gd_error("gd-jpeg: warning: jpeg_finish_decompress" + " reports suspended data source\n"); + } + /* TBB 2.0.29: we should do our best to read whatever we can read, and a + * warning is a warning. A fatal error on warnings doesn't make sense. */ +#if 0 + /* This was originally added by Truxton Fulton */ + if (cinfo.err->num_warnings > 0) + goto error; +#endif + + jpeg_destroy_decompress(&cinfo); + gdFree(row); + return im; + +error: + jpeg_destroy_decompress(&cinfo); + + if(row) { + gdFree(row); + } + if(im) { + gdImageDestroy(im); + } + + return 0; +} + +/* A very basic conversion approach, TBB */ + +static int CMYKToRGB(int c, int m, int y, int k, int inverted) +{ + if(inverted) { + c = 255 - c; + m = 255 - m; + y = 255 - y; + k = 255 - k; + } + + return gdTrueColor( + (255 - c) * (255 - k) / 255, + (255 - m) * (255 - k) / 255, + (255 - y) * (255 - k) / 255 + ); +#if 0 + if (inverted) { + c = 255 - c; + m = 255 - m; + y = 255 - y; + k = 255 - k; + } + c = c * (255 - k) / 255 + k; + if (c > 255) { + c = 255; + } + if (c < 0) { + c = 0; + } + m = m * (255 - k) / 255 + k; + if (m > 255) { + m = 255; + } + if (m < 0) { + m = 0; + } + y = y * (255 - k) / 255 + k; + if (y > 255) { + y = 255; + } + if (y < 0) { + y = 0; + } + c = 255 - c; + m = 255 - m; + y = 255 - y; + return gdTrueColor (c, m, y); +#endif +} + +/* + * gdIOCtx JPEG data sources and sinks, T. Boutell + * almost a simple global replace from T. Lane's stdio versions. + */ + +/* Different versions of libjpeg use either 'jboolean' or 'boolean', and + * some platforms define 'boolean', and so forth. Deal with this + * madness by typedeffing 'safeboolean' to 'boolean' if HAVE_BOOLEAN + * is already set, because this is the test that libjpeg uses. + * Otherwise, typedef it to int, because that's what libjpeg does + * if HAVE_BOOLEAN is not defined. -TBB + */ + +#ifdef HAVE_BOOLEAN +typedef boolean safeboolean; +#else +typedef int safeboolean; +#endif /* HAVE_BOOLEAN */ + +/* Expanded data source object for gdIOCtx input */ +typedef struct { + struct jpeg_source_mgr pub; /* public fields */ + gdIOCtx *infile; /* source stream */ + unsigned char *buffer; /* start of buffer */ + safeboolean start_of_file; /* have we gotten any data yet? */ +} +my_source_mgr; + +typedef my_source_mgr *my_src_ptr; + +#define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */ + +/* + * Initialize source --- called by jpeg_read_header + * before any data is actually read. + */ + +void init_source(j_decompress_ptr cinfo) +{ + my_src_ptr src = (my_src_ptr)cinfo->src; + + /* We reset the empty-input-file flag for each image, + * but we don't clear the input buffer. + * This is correct behavior for reading a series of images from one source. + */ + src->start_of_file = TRUE; +} + + +/* + * Fill the input buffer --- called whenever buffer is emptied. + * + * In typical applications, this should read fresh data into the buffer + * (ignoring the current state of next_input_byte & bytes_in_buffer), + * reset the pointer & count to the start of the buffer, and return TRUE + * indicating that the buffer has been reloaded. It is not necessary to + * fill the buffer entirely, only to obtain at least one more byte. + * + * There is no such thing as an EOF return. If the end of the file has been + * reached, the routine has a choice of ERREXIT() or inserting fake data into + * the buffer. In most cases, generating a warning message and inserting a + * fake EOI marker is the best course of action --- this will allow the + * decompressor to output however much of the image is there. However, + * the resulting error message is misleading if the real problem is an empty + * input file, so we handle that case specially. + * + * In applications that need to be able to suspend compression due to input + * not being available yet, a FALSE return indicates that no more data can be + * obtained right now, but more may be forthcoming later. In this situation, + * the decompressor will return to its caller (with an indication of the + * number of scanlines it has read, if any). The application should resume + * decompression after it has loaded more data into the input buffer. Note + * that there are substantial restrictions on the use of suspension --- see + * the documentation. + * + * When suspending, the decompressor will back up to a convenient restart point + * (typically the start of the current MCU). next_input_byte & bytes_in_buffer + * indicate where the restart point will be if the current call returns FALSE. + * Data beyond this point must be rescanned after resumption, so move it to + * the front of the buffer rather than discarding it. + */ + +#define END_JPEG_SEQUENCE "\r\n[*]--:END JPEG:--[*]\r\n" + +safeboolean fill_input_buffer(j_decompress_ptr cinfo) +{ + my_src_ptr src = (my_src_ptr)cinfo->src; + /* 2.0.12: signed size. Thanks to Geert Jansen */ + /* 2.0.14: some platforms (mingw-msys) don't have ssize_t. Call + * an int an int. + */ + int nbytes = 0; + memset(src->buffer, 0, INPUT_BUF_SIZE); + + while(nbytes < INPUT_BUF_SIZE) { + int got = gdGetBuf(src->buffer + nbytes, INPUT_BUF_SIZE - nbytes, src->infile); + + if((got == EOF) || (got == 0)) { + /* EOF or error. If we got any data, don't worry about it. + * If we didn't, then this is unexpected. */ + if(!nbytes) { + nbytes = -1; + } + break; + } + nbytes += got; + } + + if(nbytes <= 0) { + if(src->start_of_file) { + /* Treat empty input file as fatal error */ + ERREXIT(cinfo, JERR_INPUT_EMPTY); + } + WARNMS(cinfo, JWRN_JPEG_EOF); + /* Insert a fake EOI marker */ + src->buffer[0] = (unsigned char)0xFF; + src->buffer[1] = (unsigned char)JPEG_EOI; + nbytes = 2; + } + + src->pub.next_input_byte = src->buffer; + src->pub.bytes_in_buffer = nbytes; + src->start_of_file = FALSE; + + return TRUE; +} + +/* + * Skip data --- used to skip over a potentially large amount of + * uninteresting data (such as an APPn marker). + * + * Writers of suspendable-input applications must note that skip_input_data + * is not granted the right to give a suspension return. If the skip extends + * beyond the data currently in the buffer, the buffer can be marked empty so + * that the next read will cause a fill_input_buffer call that can suspend. + * Arranging for additional bytes to be discarded before reloading the input + * buffer is the application writer's problem. + */ + +void skip_input_data(j_decompress_ptr cinfo, long num_bytes) +{ + my_src_ptr src = (my_src_ptr)cinfo->src; + + /* Just a dumb implementation for now. Not clear that being smart is worth + * any trouble anyway --- large skips are infrequent. + */ + if(num_bytes > 0) { + while(num_bytes > (long)src->pub.bytes_in_buffer) { + num_bytes -= (long)src->pub.bytes_in_buffer; + (void)fill_input_buffer(cinfo); + /* note we assume that fill_input_buffer will never return FALSE, + * so suspension need not be handled. + */ + } + src->pub.next_input_byte += (size_t)num_bytes; + src->pub.bytes_in_buffer -= (size_t)num_bytes; + } +} + +/* + * An additional method that can be provided by data source modules is the + * resync_to_restart method for error recovery in the presence of RST markers. + * For the moment, this source module just uses the default resync method + * provided by the JPEG library. That method assumes that no backtracking + * is possible. + */ + +/* + * Terminate source --- called by jpeg_finish_decompress + * after all data has been read. Often a no-op. + * + * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding + * application must deal with any cleanup that should happen even + * for error exit. + */ +void term_source(j_decompress_ptr cinfo) +{ + (void)cinfo; +} + + +/* + * Prepare for input from a gdIOCtx stream. + * The caller must have already opened the stream, and is responsible + * for closing it after finishing decompression. + */ + +void jpeg_gdIOCtx_src(j_decompress_ptr cinfo, gdIOCtx *infile) +{ + my_src_ptr src; + + /* The source object and input buffer are made permanent so that a series + * of JPEG images can be read from the same file by calling jpeg_gdIOCtx_src + * only before the first one. (If we discarded the buffer at the end of + * one image, we'd likely lose the start of the next one.) + * This makes it unsafe to use this manager and a different source + * manager serially with the same JPEG object. Caveat programmer. + */ + if(cinfo->src == NULL) { + /* first time for this JPEG object? */ + cinfo->src = (struct jpeg_source_mgr *) + (*cinfo->mem->alloc_small)((j_common_ptr)cinfo, JPOOL_PERMANENT, + sizeof(my_source_mgr)); + src = (my_src_ptr)cinfo->src; + src->buffer = (unsigned char *) + (*cinfo->mem->alloc_small)((j_common_ptr)cinfo, JPOOL_PERMANENT, + INPUT_BUF_SIZE * sizeof(unsigned char)); + } + + src = (my_src_ptr)cinfo->src; + src->pub.init_source = init_source; + src->pub.fill_input_buffer = fill_input_buffer; + src->pub.skip_input_data = skip_input_data; + src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */ + src->pub.term_source = term_source; + src->infile = infile; + src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */ + src->pub.next_input_byte = NULL; /* until buffer loaded */ +} + +/* Expanded data destination object for stdio output */ +typedef struct { + struct jpeg_destination_mgr pub; /* public fields */ + gdIOCtx *outfile; /* target stream */ + unsigned char *buffer; /* start of buffer */ +} +my_destination_mgr; + +typedef my_destination_mgr *my_dest_ptr; + +#define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */ + +/* + * Initialize destination --- called by jpeg_start_compress + * before any data is actually written. + */ + +void init_destination(j_compress_ptr cinfo) +{ + my_dest_ptr dest = (my_dest_ptr)cinfo->dest; + + /* Allocate the output buffer --- it will be released when done with image */ + dest->buffer = (unsigned char *) + (*cinfo->mem->alloc_small)((j_common_ptr)cinfo, JPOOL_IMAGE, + OUTPUT_BUF_SIZE * sizeof(unsigned char)); + + dest->pub.next_output_byte = dest->buffer; + dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; +} + + +/* + * Empty the output buffer --- called whenever buffer fills up. + * + * In typical applications, this should write the entire output buffer + * (ignoring the current state of next_output_byte & free_in_buffer), + * reset the pointer & count to the start of the buffer, and return TRUE + * indicating that the buffer has been dumped. + * + * In applications that need to be able to suspend compression due to output + * overrun, a FALSE return indicates that the buffer cannot be emptied now. + * In this situation, the compressor will return to its caller (possibly with + * an indication that it has not accepted all the supplied scanlines). The + * application should resume compression after it has made more room in the + * output buffer. Note that there are substantial restrictions on the use of + * suspension --- see the documentation. + * + * When suspending, the compressor will back up to a convenient restart point + * (typically the start of the current MCU). next_output_byte & free_in_buffer + * indicate where the restart point will be if the current call returns FALSE. + * Data beyond this point will be regenerated after resumption, so do not + * write it out when emptying the buffer externally. + */ + +safeboolean empty_output_buffer(j_compress_ptr cinfo) +{ + my_dest_ptr dest = (my_dest_ptr)cinfo->dest; + + if(gdPutBuf(dest->buffer, OUTPUT_BUF_SIZE, dest->outfile) != (size_t)OUTPUT_BUF_SIZE) { + ERREXIT(cinfo, JERR_FILE_WRITE); + } + + dest->pub.next_output_byte = dest->buffer; + dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; + + return TRUE; +} + + +/* + * Terminate destination --- called by jpeg_finish_compress + * after all data has been written. Usually needs to flush buffer. + * + * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding + * application must deal with any cleanup that should happen even + * for error exit. + */ + +void term_destination(j_compress_ptr cinfo) +{ + my_dest_ptr dest = (my_dest_ptr) cinfo->dest; + int datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer; + + /* Write any data remaining in the buffer */ + if(datacount > 0) { + if(gdPutBuf(dest->buffer, datacount, dest->outfile) != datacount) { + ERREXIT(cinfo, JERR_FILE_WRITE); + } + } +} + +/* + * Prepare for output to a stdio stream. + * The caller must have already opened the stream, and is responsible + * for closing it after finishing compression. + */ + +void jpeg_gdIOCtx_dest(j_compress_ptr cinfo, gdIOCtx *outfile) +{ + my_dest_ptr dest; + + /* The destination object is made permanent so that multiple JPEG images + * can be written to the same file without re-executing jpeg_stdio_dest. + * This makes it dangerous to use this manager and a different destination + * manager serially with the same JPEG object, because their private object + * sizes may be different. Caveat programmer. + */ + if(cinfo->dest == NULL) { + /* first time for this JPEG object? */ + cinfo->dest = (struct jpeg_destination_mgr *) + (*cinfo->mem->alloc_small)((j_common_ptr)cinfo, JPOOL_PERMANENT, + sizeof(my_destination_mgr)); + } + + dest = (my_dest_ptr)cinfo->dest; + dest->pub.init_destination = init_destination; + dest->pub.empty_output_buffer = empty_output_buffer; + dest->pub.term_destination = term_destination; + dest->outfile = outfile; +} + +#endif /* HAVE_LIBJPEG */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_matrix.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_matrix.c new file mode 100644 index 00000000000..182ea35b546 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_matrix.c @@ -0,0 +1,336 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif /* HAVE_CONFIG_H */ + +#include "gd.h" +#include <math.h> + +#ifndef M_PI +# define M_PI 3.14159265358979323846 +#endif + +/** + * Title: Matrix + * Group: Affine Matrix + */ + +/** + * Function: gdAffineApplyToPointF + * Applies an affine transformation to a point (floating point + * gdPointF) + * + * + * Parameters: + * dst - Where to store the resulting point + * affine - Source Point + * flip_horz - affine matrix + * + * Returns: + * GD_TRUE if the affine is rectilinear or GD_FALSE + */ +BGD_DECLARE(int) gdAffineApplyToPointF (gdPointFPtr dst, const gdPointFPtr src, + const double affine[6]) +{ + double x = src->x; + double y = src->y; + dst->x = x * affine[0] + y * affine[2] + affine[4]; + dst->y = x * affine[1] + y * affine[3] + affine[5]; + return GD_TRUE; +} + +/** + * Function: gdAffineInvert + * Find the inverse of an affine transformation. + * + * All non-degenerate affine transforms are invertible. Applying the + * inverted matrix will restore the original values. Multiplying <src> + * by <dst> (commutative) will return the identity affine (rounding + * error possible). + * + * Parameters: + * dst - Where to store the resulting affine transform + * src_affine - Original affine matrix + * flip_horz - Whether or not to flip horizontally + * flip_vert - Whether or not to flip vertically + * + * See also: + * <gdAffineIdentity> + * + * Returns: + * GD_TRUE if the affine is rectilinear or GD_FALSE + */ +BGD_DECLARE(int) gdAffineInvert (double dst[6], const double src[6]) +{ + double r_det = (src[0] * src[3] - src[1] * src[2]); + + if (r_det <= 0.0) { + return GD_FALSE; + } + + r_det = 1.0 / r_det; + dst[0] = src[3] * r_det; + dst[1] = -src[1] * r_det; + dst[2] = -src[2] * r_det; + dst[3] = src[0] * r_det; + dst[4] = -src[4] * dst[0] - src[5] * dst[2]; + dst[5] = -src[4] * dst[1] - src[5] * dst[3]; + return GD_TRUE; +} + +/** + * Function: gdAffineFlip + * Flip an affine transformation horizontally or vertically. + * + * Flips the affine transform, giving GD_FALSE for <flip_horz> and + * <flip_vert> will clone the affine matrix. GD_TRUE for both will + * copy a 180° rotation. + * + * Parameters: + * dst - Where to store the resulting affine transform + * src_affine - Original affine matrix + * flip_h - Whether or not to flip horizontally + * flip_v - Whether or not to flip vertically + * + * Returns: + * GD_TRUE on success or GD_FALSE + */ +BGD_DECLARE(int) gdAffineFlip (double dst[6], const double src[6], const int flip_h, const int flip_v) +{ + dst[0] = flip_h ? - src[0] : src[0]; + dst[1] = flip_h ? - src[1] : src[1]; + dst[2] = flip_v ? - src[2] : src[2]; + dst[3] = flip_v ? - src[3] : src[3]; + dst[4] = flip_h ? - src[4] : src[4]; + dst[5] = flip_v ? - src[5] : src[5]; + return GD_TRUE; +} + +/** + * Function: gdAffineConcat + * Concat (Multiply) two affine transformation matrices. + * + * Concats two affine transforms together, i.e. the result + * will be the equivalent of doing first the transformation m1 and then + * m2. All parameters can be the same matrix (safe to call using + * the same array for all three arguments). + * + * Parameters: + * dst - Where to store the resulting affine transform + * m1 - First affine matrix + * m2 - Second affine matrix + * + * Returns: + * GD_TRUE on success or GD_FALSE + */ +BGD_DECLARE(int) gdAffineConcat (double dst[6], const double m1[6], const double m2[6]) +{ + double dst0, dst1, dst2, dst3, dst4, dst5; + + dst0 = m1[0] * m2[0] + m1[1] * m2[2]; + dst1 = m1[0] * m2[1] + m1[1] * m2[3]; + dst2 = m1[2] * m2[0] + m1[3] * m2[2]; + dst3 = m1[2] * m2[1] + m1[3] * m2[3]; + dst4 = m1[4] * m2[0] + m1[5] * m2[2] + m2[4]; + dst5 = m1[4] * m2[1] + m1[5] * m2[3] + m2[5]; + dst[0] = dst0; + dst[1] = dst1; + dst[2] = dst2; + dst[3] = dst3; + dst[4] = dst4; + dst[5] = dst5; + return GD_TRUE; +} + +/** + * Function: gdAffineIdentity + * Set up the identity matrix. + * + * Parameters: + * dst - Where to store the resulting affine transform + * + * Returns: + * GD_TRUE on success or GD_FALSE + */ +BGD_DECLARE(int) gdAffineIdentity (double dst[6]) +{ + dst[0] = 1; + dst[1] = 0; + dst[2] = 0; + dst[3] = 1; + dst[4] = 0; + dst[5] = 0; + return GD_TRUE; +} + +/** + * Function: gdAffineScale + * Set up a scaling matrix. + * + * Parameters: + * scale_x - X scale factor + * scale_y - Y scale factor + * + * Returns: + * GD_TRUE on success or GD_FALSE + */ +BGD_DECLARE(int) gdAffineScale (double dst[6], const double scale_x, const double scale_y) +{ + dst[0] = scale_x; + dst[1] = 0; + dst[2] = 0; + dst[3] = scale_y; + dst[4] = 0; + dst[5] = 0; + return GD_TRUE; +} + +/** + * Function: gdAffineRotate + * Set up a rotation affine transform. + * + * Like the other angle in libGD, in which increasing y moves + * downward, this is a counterclockwise rotation. + * + * Parameters: + * dst - Where to store the resulting affine transform + * angle - Rotation angle in degrees + * + * Returns: + * GD_TRUE on success or GD_FALSE + */ +BGD_DECLARE(int) gdAffineRotate (double dst[6], const double angle) +{ + const double sin_t = sin (angle * M_PI / 180.0); + const double cos_t = cos (angle * M_PI / 180.0); + + dst[0] = cos_t; + dst[1] = sin_t; + dst[2] = -sin_t; + dst[3] = cos_t; + dst[4] = 0; + dst[5] = 0; + return GD_TRUE; +} + +/** + * Function: gdAffineShearHorizontal + * Set up a horizontal shearing matrix || becomes \\. + * + * Parameters: + * dst - Where to store the resulting affine transform + * angle - Shear angle in degrees + * + * Returns: + * GD_TRUE on success or GD_FALSE + */ +BGD_DECLARE(int) gdAffineShearHorizontal(double dst[6], const double angle) +{ + dst[0] = 1; + dst[1] = 0; + dst[2] = tan(angle * M_PI / 180.0); + dst[3] = 1; + dst[4] = 0; + dst[5] = 0; + return GD_TRUE; +} + +/** + * Function: gdAffineShearVertical + * Set up a vertical shearing matrix, columns are untouched. + * + * Parameters: + * dst - Where to store the resulting affine transform + * angle - Shear angle in degrees + * + * Returns: + * GD_TRUE on success or GD_FALSE + */ +BGD_DECLARE(int) gdAffineShearVertical(double dst[6], const double angle) +{ + dst[0] = 1; + dst[1] = tan(angle * M_PI / 180.0);; + dst[2] = 0; + dst[3] = 1; + dst[4] = 0; + dst[5] = 0; + return GD_TRUE; +} + +/** + * Function: gdAffineTranslate + * Set up a translation matrix. + * + * Parameters: + * dst - Where to store the resulting affine transform + * offset_x - Horizontal translation amount + * offset_y - Vertical translation amount + * + * Returns: + * GD_TRUE on success or GD_FALSE + */ +BGD_DECLARE(int) gdAffineTranslate (double dst[6], const double offset_x, const double offset_y) +{ + dst[0] = 1; + dst[1] = 0; + dst[2] = 0; + dst[3] = 1; + dst[4] = offset_x; + dst[5] = offset_y; + return GD_TRUE; +} + +/** + * gdAffineexpansion: Find the affine's expansion factor. + * @src: The affine transformation. + * + * Finds the expansion factor, i.e. the square root of the factor + * by which the affine transform affects area. In an affine transform + * composed of scaling, rotation, shearing, and translation, returns + * the amount of scaling. + * + * GD_TRUE on success or GD_FALSE + **/ +BGD_DECLARE(double) gdAffineExpansion (const double src[6]) +{ + return sqrt (fabs (src[0] * src[3] - src[1] * src[2])); +} + +/** + * Function: gdAffineRectilinear + * Determines whether the affine transformation is axis aligned. A + * tolerance has been implemented using GD_EPSILON. + * + * Parameters: + * m - The affine transformation + * + * Returns: + * GD_TRUE if the affine is rectilinear or GD_FALSE + */ +BGD_DECLARE(int) gdAffineRectilinear (const double m[6]) +{ + return ((fabs (m[1]) < GD_EPSILON && fabs (m[2]) < GD_EPSILON) || + (fabs (m[0]) < GD_EPSILON && fabs (m[3]) < GD_EPSILON)); +} + +/** + * Function: gdAffineEqual + * Determines whether two affine transformations are equal. A tolerance + * has been implemented using GD_EPSILON. + * + * Parameters: + * m1 - The first affine transformation + * m2 - The first affine transformation + * + * Returns: + * GD_TRUE on success or GD_FALSE + */ +BGD_DECLARE(int) gdAffineEqual (const double m1[6], const double m2[6]) +{ + return (fabs (m1[0] - m2[0]) < GD_EPSILON && + fabs (m1[1] - m2[1]) < GD_EPSILON && + fabs (m1[2] - m2[2]) < GD_EPSILON && + fabs (m1[3] - m2[3]) < GD_EPSILON && + fabs (m1[4] - m2[4]) < GD_EPSILON && + fabs (m1[5] - m2[5]) < GD_EPSILON); +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_nnquant.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_nnquant.c new file mode 100644 index 00000000000..c4b43d6ea35 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_nnquant.c @@ -0,0 +1,627 @@ +/* NeuQuant Neural-Net Quantization Algorithm + * ------------------------------------------ + * + * Copyright (c) 1994 Anthony Dekker + * + * NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994. + * See "Kohonen neural networks for optimal colour quantization" + * in "Network: Computation in Neural Systems" Vol. 5 (1994) pp 351-367. + * for a discussion of the algorithm. + * See also http://members.ozemail.com.au/~dekker/NEUQUANT.HTML + * + * Any party obtaining a copy of these files from the author, directly or + * indirectly, is granted, free of charge, a full and unrestricted irrevocable, + * world-wide, paid up, royalty-free, nonexclusive right and license to deal + * in this software and documentation files (the "Software"), including without + * limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons who receive + * copies from any such party to do so, with the only requirement being + * that this copyright notice remain intact. + * + * + * Modified to process 32bit RGBA images. + * Stuart Coyle 2004-2007 + * From: http://pngnq.sourceforge.net/ + * + * Ported to libgd by Pierre A. Joye + * (and make it thread safety by droping static and global variables) + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif /* HAVE_CONFIG_H */ + +#include <stdlib.h> +#include <string.h> +#include "gd.h" +#include "gdhelpers.h" +#include "gd_errors.h" + +#include "gd_nnquant.h" + +/* Network Definitions + ------------------- */ + +#define maxnetpos (MAXNETSIZE-1) +#define netbiasshift 4 /* bias for colour values */ +#define ncycles 100 /* no. of learning cycles */ + +/* defs for freq and bias */ +#define intbiasshift 16 /* bias for fractions */ +#define intbias (((int) 1)<<intbiasshift) +#define gammashift 10 /* gamma = 1024 */ +#define gamma (((int) 1)<<gammashift) +#define betashift 10 +#define beta (intbias>>betashift) /* beta = 1/1024 */ +#define betagamma (intbias<<(gammashift-betashift)) + +/* defs for decreasing radius factor */ +#define initrad (MAXNETSIZE>>3) /* for 256 cols, radius starts */ +#define radiusbiasshift 6 /* at 32.0 biased by 6 bits */ +#define radiusbias (((int) 1)<<radiusbiasshift) +#define initradius (initrad*radiusbias) /* and decreases by a */ +#define radiusdec 30 /* factor of 1/30 each cycle */ + +/* defs for decreasing alpha factor */ +#define alphabiasshift 10 /* alpha starts at 1.0 */ +#define initalpha (((int) 1)<<alphabiasshift) +int alphadec; + +/* radbias and alpharadbias used for radpower calculation */ +#define radbiasshift 8 +#define radbias (((int) 1)<<radbiasshift) +#define alpharadbshift (alphabiasshift+radbiasshift) +#define alpharadbias (((int) 1)<<alpharadbshift) + +#define ALPHA 0 +#define RED 1 +#define BLUE 2 +#define GREEN 3 + +typedef int nq_pixel[5]; + +typedef struct { + /* biased by 10 bits */ + int alphadec; + + /* lengthcount = H*W*3 */ + int lengthcount; + + /* sampling factor 1..30 */ + int samplefac; + + /* Number of colours to use. Made a global instead of #define */ + int netsize; + + /* for network lookup - really 256 */ + int netindex[256]; + + /* ABGRc */ + /* the network itself */ + nq_pixel network[MAXNETSIZE]; + + /* bias and freq arrays for learning */ + int bias[MAXNETSIZE]; + int freq[MAXNETSIZE]; + + /* radpower for precomputation */ + int radpower[initrad]; + + /* the input image itself */ + unsigned char *thepicture; +} nn_quant; + +/* Initialise network in range (0,0,0,0) to (255,255,255,255) and set parameters + ----------------------------------------------------------------------- */ +void initnet(nnq, thepic, len, sample, colours) +nn_quant *nnq; +unsigned char *thepic; +int len; +int sample; +int colours; +{ + register int i; + register int *p; + + /* Clear out network from previous runs */ + /* thanks to Chen Bin for this fix */ + memset((void*)nnq->network, 0, sizeof(nq_pixel)*MAXNETSIZE); + + nnq->thepicture = thepic; + nnq->lengthcount = len; + nnq->samplefac = sample; + nnq->netsize = colours; + + for (i=0; i < nnq->netsize; i++) { + p = nnq->network[i]; + p[0] = p[1] = p[2] = p[3] = (i << (netbiasshift+8)) / nnq->netsize; + nnq->freq[i] = intbias / nnq->netsize; /* 1/netsize */ + nnq->bias[i] = 0; + } +} + +/* -------------------------- */ + +/* Unbias network to give byte values 0..255 and record + * position i to prepare for sort + */ +/* -------------------------- */ + +void unbiasnet(nn_quant *nnq) +{ + int i,j,temp; + + for (i=0; i < nnq->netsize; i++) { + for (j=0; j<4; j++) { + /* OLD CODE: network[i][j] >>= netbiasshift; */ + /* Fix based on bug report by Juergen Weigert jw@suse.de */ + temp = (nnq->network[i][j] + (1 << (netbiasshift - 1))) >> netbiasshift; + if (temp > 255) temp = 255; + nnq->network[i][j] = temp; + } + nnq->network[i][4] = i; /* record colour no */ + } +} + +/* Output colour map + ----------------- */ +void writecolourmap(nnq, f) +nn_quant *nnq; +FILE *f; +{ + int i,j; + + for (i=3; i>=0; i--) + for (j=0; j < nnq->netsize; j++) + putc(nnq->network[j][i], f); +} + +/* Output colormap to unsigned char ptr in RGBA format */ +void getcolormap(nnq, map) +nn_quant *nnq; +unsigned char *map; +{ + int i,j; + for(j=0; j < nnq->netsize; j++) { + for (i=3; i>=0; i--) { + *map = nnq->network[j][i]; + map++; + } + } +} + +/* Insertion sort of network and building of netindex[0..255] (to do after unbias) + ------------------------------------------------------------------------------- */ +void inxbuild(nn_quant *nnq) +{ + register int i,j,smallpos,smallval; + register int *p,*q; + int previouscol,startpos; + + previouscol = 0; + startpos = 0; + for (i=0; i < nnq->netsize; i++) { + p = nnq->network[i]; + smallpos = i; + smallval = p[2]; /* index on g */ + /* find smallest in i..netsize-1 */ + for (j=i+1; j < nnq->netsize; j++) { + q = nnq->network[j]; + if (q[2] < smallval) { /* index on g */ + smallpos = j; + smallval = q[2]; /* index on g */ + } + } + q = nnq->network[smallpos]; + /* swap p (i) and q (smallpos) entries */ + if (i != smallpos) { + j = q[0]; + q[0] = p[0]; + p[0] = j; + j = q[1]; + q[1] = p[1]; + p[1] = j; + j = q[2]; + q[2] = p[2]; + p[2] = j; + j = q[3]; + q[3] = p[3]; + p[3] = j; + j = q[4]; + q[4] = p[4]; + p[4] = j; + } + /* smallval entry is now in position i */ + if (smallval != previouscol) { + nnq->netindex[previouscol] = (startpos+i)>>1; + for (j=previouscol+1; j<smallval; j++) nnq->netindex[j] = i; + previouscol = smallval; + startpos = i; + } + } + nnq->netindex[previouscol] = (startpos+maxnetpos)>>1; + for (j=previouscol+1; j<256; j++) nnq->netindex[j] = maxnetpos; /* really 256 */ +} + + +/* Search for ABGR values 0..255 (after net is unbiased) and return colour index + ---------------------------------------------------------------------------- */ +int inxsearch(nnq, al,b,g,r) +nn_quant *nnq; +register int al, b, g, r; +{ + register int i, j, dist, a, bestd; + register int *p; + int best; + + bestd = 1000; /* biggest possible dist is 256*3 */ + best = -1; + i = nnq->netindex[g]; /* index on g */ + j = i-1; /* start at netindex[g] and work outwards */ + + while ((i<nnq->netsize) || (j>=0)) { + if (i< nnq->netsize) { + p = nnq->network[i]; + dist = p[2] - g; /* inx key */ + if (dist >= bestd) i = nnq->netsize; /* stop iter */ + else { + i++; + if (dist<0) dist = -dist; + a = p[1] - b; + if (a<0) a = -a; + dist += a; + if (dist<bestd) { + a = p[3] - r; + if (a<0) a = -a; + dist += a; + } + if(dist<bestd) { + a = p[0] - al; + if (a<0) a = -a; + dist += a; + } + if (dist<bestd) { + bestd=dist; + best=p[4]; + } + } + } + + if (j>=0) { + p = nnq->network[j]; + dist = g - p[2]; /* inx key - reverse dif */ + if (dist >= bestd) j = -1; /* stop iter */ + else { + j--; + if (dist<0) dist = -dist; + a = p[1] - b; + if (a<0) a = -a; + dist += a; + if (dist<bestd) { + a = p[3] - r; + if (a<0) a = -a; + dist += a; + } + if(dist<bestd) { + a = p[0] - al; + if (a<0) a = -a; + dist += a; + } + if (dist<bestd) { + bestd=dist; + best=p[4]; + } + } + } + } + + return(best); +} + +/* Search for biased ABGR values + ---------------------------- */ +int contest(nnq, al,b,g,r) +nn_quant *nnq; +register int al,b,g,r; +{ + /* finds closest neuron (min dist) and updates freq */ + /* finds best neuron (min dist-bias) and returns position */ + /* for frequently chosen neurons, freq[i] is high and bias[i] is negative */ + /* bias[i] = gamma*((1/netsize)-freq[i]) */ + + register int i,dist,a,biasdist,betafreq; + int bestpos,bestbiaspos,bestd,bestbiasd; + register int *p,*f, *n; + + bestd = ~(((int) 1)<<31); + bestbiasd = bestd; + bestpos = -1; + bestbiaspos = bestpos; + p = nnq->bias; + f = nnq->freq; + + for (i=0; i< nnq->netsize; i++) { + n = nnq->network[i]; + dist = n[0] - al; + if (dist<0) dist = -dist; + a = n[1] - b; + if (a<0) a = -a; + dist += a; + a = n[2] - g; + if (a<0) a = -a; + dist += a; + a = n[3] - r; + if (a<0) a = -a; + dist += a; + if (dist<bestd) { + bestd=dist; + bestpos=i; + } + biasdist = dist - ((*p)>>(intbiasshift-netbiasshift)); + if (biasdist<bestbiasd) { + bestbiasd=biasdist; + bestbiaspos=i; + } + betafreq = (*f >> betashift); + *f++ -= betafreq; + *p++ += (betafreq<<gammashift); + } + nnq->freq[bestpos] += beta; + nnq->bias[bestpos] -= betagamma; + return(bestbiaspos); +} + + +/* Move neuron i towards biased (a,b,g,r) by factor alpha + ---------------------------------------------------- */ + +void altersingle(nnq, alpha,i,al,b,g,r) +nn_quant *nnq; +register int alpha,i,al,b,g,r; +{ + register int *n; + + n = nnq->network[i]; /* alter hit neuron */ + *n -= (alpha*(*n - al)) / initalpha; + n++; + *n -= (alpha*(*n - b)) / initalpha; + n++; + *n -= (alpha*(*n - g)) / initalpha; + n++; + *n -= (alpha*(*n - r)) / initalpha; +} + + +/* Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in radpower[|i-j|] + --------------------------------------------------------------------------------- */ + +void alterneigh(nnq, rad,i,al,b,g,r) +nn_quant *nnq; +int rad,i; +register int al,b,g,r; +{ + register int j,k,lo,hi,a; + register int *p, *q; + + lo = i-rad; + if (lo<-1) lo=-1; + hi = i+rad; + if (hi>nnq->netsize) hi=nnq->netsize; + + j = i+1; + k = i-1; + q = nnq->radpower; + while ((j<hi) || (k>lo)) { + a = (*(++q)); + if (j<hi) { + p = nnq->network[j]; + *p -= (a*(*p - al)) / alpharadbias; + p++; + *p -= (a*(*p - b)) / alpharadbias; + p++; + *p -= (a*(*p - g)) / alpharadbias; + p++; + *p -= (a*(*p - r)) / alpharadbias; + j++; + } + if (k>lo) { + p = nnq->network[k]; + *p -= (a*(*p - al)) / alpharadbias; + p++; + *p -= (a*(*p - b)) / alpharadbias; + p++; + *p -= (a*(*p - g)) / alpharadbias; + p++; + *p -= (a*(*p - r)) / alpharadbias; + k--; + } + } +} + + +/* Main Learning Loop + ------------------ */ + +void learn(nnq, verbose) /* Stu: N.B. added parameter so that main() could control verbosity. */ +nn_quant *nnq; +int verbose; +{ + register int i,j,al,b,g,r; + int radius,rad,alpha,step,delta,samplepixels; + register unsigned char *p; + unsigned char *lim; + + nnq->alphadec = 30 + ((nnq->samplefac-1)/3); + p = nnq->thepicture; + lim = nnq->thepicture + nnq->lengthcount; + samplepixels = nnq->lengthcount/(4 * nnq->samplefac); + /* here's a problem with small images: samplepixels < ncycles => delta = 0 */ + delta = samplepixels/ncycles; + /* kludge to fix */ + if(delta==0) delta = 1; + alpha = initalpha; + radius = initradius; + + rad = radius >> radiusbiasshift; + if (rad <= 1) rad = 0; + for (i=0; i<rad; i++) + nnq->radpower[i] = alpha*(((rad*rad - i*i)*radbias)/(rad*rad)); + + if (verbose) gd_error_ex(GD_NOTICE, "beginning 1D learning: initial radius=%d\n", rad); + + if ((nnq->lengthcount%prime1) != 0) step = 4*prime1; + else { + if ((nnq->lengthcount%prime2) !=0) step = 4*prime2; + else { + if ((nnq->lengthcount%prime3) !=0) step = 4*prime3; + else step = 4*prime4; + } + } + + i = 0; + while (i < samplepixels) { + al = p[ALPHA] << netbiasshift; + b = p[BLUE] << netbiasshift; + g = p[GREEN] << netbiasshift; + r = p[RED] << netbiasshift; + j = contest(nnq, al,b,g,r); + + altersingle(nnq, alpha,j,al,b,g,r); + if (rad) alterneigh(nnq, rad,j,al,b,g,r); /* alter neighbours */ + + p += step; + while (p >= lim) p -= nnq->lengthcount; + + i++; + if (i%delta == 0) { /* FPE here if delta=0*/ + alpha -= alpha / nnq->alphadec; + radius -= radius / radiusdec; + rad = radius >> radiusbiasshift; + if (rad <= 1) rad = 0; + for (j=0; j<rad; j++) + nnq->radpower[j] = alpha*(((rad*rad - j*j)*radbias)/(rad*rad)); + } + } + if (verbose) gd_error_ex(GD_NOTICE, "finished 1D learning: final alpha=%f !\n",((float)alpha)/initalpha); +} + +BGD_DECLARE(gdImagePtr) gdImageNeuQuant(gdImagePtr im, const int max_color, int sample_factor) +{ + const int newcolors = max_color; + const int verbose = 1; + + int bot_idx, top_idx; /* for remapping of indices */ + int remap[MAXNETSIZE]; + int i,x; + + unsigned char map[MAXNETSIZE][4]; + unsigned char *d; + + nn_quant *nnq = NULL; + + int row; + unsigned char *rgba = NULL; + gdImagePtr dst = NULL; + + /* Default it to 3 */ + if (sample_factor < 1) { + sample_factor = 3; + } + /* Start neuquant */ + /* Pierre: + * This implementation works with aligned contiguous buffer only + * Upcoming new buffers are contiguous and will be much faster. + * let don't bloat this code to support our good "old" 31bit format. + * It alos lets us convert palette image, if one likes to reduce + * a palette + */ + if (overflow2(gdImageSX(im), gdImageSY(im)) + || overflow2(gdImageSX(im) * gdImageSY(im), 4)) { + goto done; + } + rgba = (unsigned char *) gdMalloc(gdImageSX(im) * gdImageSY(im) * 4); + if (!rgba) { + goto done; + } + + d = rgba; + for (row = 0; row < gdImageSY(im); row++) { + int *p = im->tpixels[row]; + register int c; + + for (i = 0; i < gdImageSX(im); i++) { + c = *p; + *d++ = gdImageAlpha(im, c); + *d++ = gdImageRed(im, c); + *d++ = gdImageBlue(im, c); + *d++ = gdImageGreen(im, c); + p++; + } + } + + nnq = (nn_quant *) gdMalloc(sizeof(nn_quant)); + if (!nnq) { + goto done; + } + + initnet(nnq, rgba, gdImageSY(im) * gdImageSX(im) * 4, sample_factor, newcolors); + + learn(nnq, verbose); + unbiasnet(nnq); + getcolormap(nnq, (unsigned char*)map); + inxbuild(nnq); + /* remapping colormap to eliminate opaque tRNS-chunk entries... */ + for (top_idx = newcolors-1, bot_idx = x = 0; x < newcolors; ++x) { + if (map[x][3] == 255) { /* maxval */ + remap[x] = top_idx--; + } else { + remap[x] = bot_idx++; + } + } + if (bot_idx != top_idx + 1) { + gd_error(" internal logic error: remapped bot_idx = %d, top_idx = %d\n", + bot_idx, top_idx); + goto done; + } + + dst = gdImageCreate(gdImageSX(im), gdImageSY(im)); + if (!dst) { + goto done; + } + + for (x = 0; x < newcolors; ++x) { + dst->red[remap[x]] = map[x][0]; + dst->green[remap[x]] = map[x][1]; + dst->blue[remap[x]] = map[x][2]; + dst->alpha[remap[x]] = map[x][3]; + dst->open[remap[x]] = 0; + dst->colorsTotal++; + } + + /* Do each image row */ + for ( row = 0; row < gdImageSY(im); ++row ) { + int offset; + unsigned char *p = dst->pixels[row]; + + /* Assign the new colors */ + offset = row * gdImageSX(im) * 4; + for(i=0; i < gdImageSX(im); i++) { + p[i] = remap[ + inxsearch(nnq, rgba[i * 4 + offset + ALPHA], + rgba[i * 4 + offset + BLUE], + rgba[i * 4 + offset + GREEN], + rgba[i * 4 + offset + RED]) + ]; + } + } + +done: + if (rgba) { + gdFree(rgba); + } + + if (nnq) { + gdFree(nnq); + } + return dst; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_nnquant.h b/Build/source/libs/gd/libgd-2.1.1/src/gd_nnquant.h new file mode 100644 index 00000000000..b054fb1da44 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_nnquant.h @@ -0,0 +1,19 @@ + +/* maximum number of colours that can be used. + actual number is now passed to initcolors */ +#define MAXNETSIZE 256 + +/* For 256 colours, fixed arrays need 8kb, plus space for the image + ---------------------------------------------------------------- */ + + +/* four primes near 500 - assume no image has a length so large */ +/* that it is divisible by all four primes */ +#define prime1 499 +#define prime2 491 +#define prime3 487 +#define prime4 503 + +#define minpicturebytes (4*prime4) /* minimum size for input image */ + + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_png.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_png.c new file mode 100644 index 00000000000..95139e8b8b5 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_png.c @@ -0,0 +1,1074 @@ +/* $Id$ */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include "gd.h" +#include "gd_errors.h" + +/* JCE: Arrange HAVE_LIBPNG so that it can be set in gd.h */ +#ifdef HAVE_LIBPNG + +#include "gdhelpers.h" +#include "png.h" /* includes zlib.h and setjmp.h */ + +#define TRUE 1 +#define FALSE 0 + +/*--------------------------------------------------------------------------- + + gd_png.c Copyright 1999 Greg Roelofs and Thomas Boutell + + The routines in this file, gdImagePng*() and gdImageCreateFromPng*(), + are drop-in replacements for gdImageGif*() and gdImageCreateFromGif*(), + except that these functions are noisier in the case of errors (comment + out all fprintf() statements to disable that). + + GD 2.0 supports RGBA truecolor and will read and write truecolor PNGs. + GD 2.0 supports 8 bits of color resolution per channel and + 7 bits of alpha channel resolution. Images with more than 8 bits + per channel are reduced to 8 bits. Images with an alpha channel are + only able to resolve down to '1/128th opaque' instead of '1/256th', + and this conversion is also automatic. I very much doubt you can see it. + Both tRNS and true alpha are supported. + + Gamma is ignored, and there is no support for text annotations. + + Last updated: 9 February 2001 + + ---------------------------------------------------------------------------*/ + +#ifdef PNG_SETJMP_SUPPORTED +typedef struct _jmpbuf_wrapper { + jmp_buf jmpbuf; +} +jmpbuf_wrapper; + +static void +gdPngErrorHandler (png_structp png_ptr, png_const_charp msg) +{ + jmpbuf_wrapper *jmpbuf_ptr; + + /* This function, aside from the extra step of retrieving the "error + * pointer" (below) and the fact that it exists within the application + * rather than within libpng, is essentially identical to libpng's + * default error handler. The second point is critical: since both + * setjmp() and longjmp() are called from the same code, they are + * guaranteed to have compatible notions of how big a jmp_buf is, + * regardless of whether _BSD_SOURCE or anything else has (or has not) + * been defined. */ + + gd_error_ex(GD_ERROR, "gd-png: fatal libpng error: %s\n", msg); + + jmpbuf_ptr = png_get_error_ptr (png_ptr); + if (jmpbuf_ptr == NULL) { /* we are completely hosed now */ + gd_error_ex(GD_ERROR, "gd-png: EXTREMELY fatal error: jmpbuf unrecoverable; terminating.\n"); + exit (99); + } + + longjmp (jmpbuf_ptr->jmpbuf, 1); +} +#endif + +static void +gdPngReadData (png_structp png_ptr, png_bytep data, png_size_t length) +{ + int check; + check = gdGetBuf (data, length, (gdIOCtx *) png_get_io_ptr (png_ptr)); + if (check != (int)length) { + png_error(png_ptr, "Read Error: truncated data"); + } +} + +static void +gdPngWriteData (png_structp png_ptr, png_bytep data, png_size_t length) +{ + gdPutBuf (data, length, (gdIOCtx *) png_get_io_ptr (png_ptr)); +} + +static void +gdPngFlushData (png_structp png_ptr) +{ + (void)png_ptr; +} + +/* + Function: gdImageCreateFromPng + + <gdImageCreateFromPng> is called to load images from PNG format + files. Invoke <gdImageCreateFromPng> with an already opened + pointer to a FILE containing the desired + image. <gdImageCreateFromPng> returns a <gdImagePtr> to the new + image, or NULL if unable to load the image (most often because the + file is corrupt or does not contain a PNG + image). <gdImageCreateFromPng> does not close the file. You can + inspect the sx and sy members of the image to determine its + size. The image must eventually be destroyed using + gdImageDestroy(). + + If the PNG image being loaded is a truecolor image, the resulting + gdImagePtr will refer to a truecolor image. If the PNG image being + loaded is a palette or grayscale image, the resulting gdImagePtr + will refer to a palette image. gd retains only 8 bits of + resolution for each of the red, green and blue channels, and only + 7 bits of resolution for the alpha channel. The former restriction + affects only a handful of very rare 48-bit color and 16-bit + grayscale PNG images. The second restriction affects all + semitransparent PNG images, but the difference is essentially + invisible to the eye. 7 bits of alpha channel resolution is, in + practice, quite a lot. + + Variants: + + <gdImageCreateFromPngPtr> creates an image from PNG data (i.e. the + contents of a PNG file) already in memory. + + <gdImageCreateFromPngCtx> reads in an image using the functions in + a <gdIOCtx> struct. + + <gdImageCreateFromPngSource> is similar to + <gdImageCreateFromPngCtx> but uses the old <gdSource> interface. + It is *obsolete*. + + Parameters: + + infile - The input FILE pointer. + + Returns: + + A pointer to the new image or NULL if an error occurred. + + Example: + + > gdImagePtr im; + > ... inside a function ... + > FILE *in; + > in = fopen("mypng.png", "rb"); + > im = gdImageCreateFromPng(in); + > fclose(in); + > // ... Use the image ... + > gdImageDestroy(im); + + */ +BGD_DECLARE(gdImagePtr) gdImageCreateFromPng (FILE * inFile) +{ + gdImagePtr im; + gdIOCtx *in = gdNewFileCtx (inFile); + if (in == NULL) return NULL; + im = gdImageCreateFromPngCtx (in); + in->gd_free (in); + return im; +} + +/* + Function: gdImageCreateFromPngPtr + + See <gdImageCreateFromPng>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromPngPtr (int size, void *data) +{ + gdImagePtr im; + gdIOCtx *in = gdNewDynamicCtxEx (size, data, 0); + if(!in) + return 0; + im = gdImageCreateFromPngCtx (in); + in->gd_free (in); + return im; +} + + + +/* This routine is based in part on the Chapter 13 demo code in + * "PNG: The Definitive Guide" (http://www.libpng.org/pub/png/book/). + */ + +/* + Function: gdImageCreateFromPngCtx + + See <gdImageCreateFromPng>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromPngCtx (gdIOCtx * infile) +{ + png_byte sig[8]; +#ifdef PNG_SETJMP_SUPPORTED + jmpbuf_wrapper jbw; +#endif + png_structp png_ptr; + png_infop info_ptr; + png_uint_32 width, height, rowbytes, w, h, res_x, res_y; + int bit_depth, color_type, interlace_type, unit_type; + int num_palette = 0, num_trans; + png_colorp palette; + png_color_16p trans_gray_rgb; + png_color_16p trans_color_rgb; + png_bytep trans; + png_bytep image_data = NULL; + png_bytepp row_pointers = NULL; + gdImagePtr im = NULL; + int i, j, *open = NULL; + volatile int transparent = -1; + volatile int palette_allocated = FALSE; + + /* Make sure the signature can't match by dumb luck -- TBB */ + /* GRR: isn't sizeof(infile) equal to the size of the pointer? */ + memset (sig, 0, sizeof (sig)); + + /* first do a quick check that the file really is a PNG image; could + * have used slightly more general png_sig_cmp() function instead */ + if (gdGetBuf (sig, 8, infile) < 8) { + return NULL; + } + + if (png_sig_cmp(sig, 0, 8) != 0) { /* bad signature */ + return NULL; /* bad signature */ + } + +#ifdef PNG_SETJMP_SUPPORTED + png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, &jbw, gdPngErrorHandler, NULL); +#else + png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); +#endif + if (png_ptr == NULL) { + gd_error("gd-png error: cannot allocate libpng main struct\n"); + return NULL; + } + + info_ptr = png_create_info_struct (png_ptr); + if (info_ptr == NULL) { + gd_error("gd-png error: cannot allocate libpng info struct\n"); + png_destroy_read_struct (&png_ptr, NULL, NULL); + + return NULL; + } + + /* we could create a second info struct here (end_info), but it's only + * useful if we want to keep pre- and post-IDAT chunk info separated + * (mainly for PNG-aware image editors and converters) + */ + + /* setjmp() must be called in every non-callback function that calls a + * PNG-reading libpng function */ +#ifdef PNG_SETJMP_SUPPORTED + if (setjmp(jbw.jmpbuf)) { + gd_error("gd-png error: setjmp returns error condition 1\n"); + png_destroy_read_struct (&png_ptr, &info_ptr, NULL); + + return NULL; + } +#endif + + png_set_sig_bytes (png_ptr, 8); /* we already read the 8 signature bytes */ + + png_set_read_fn (png_ptr, (void *) infile, gdPngReadData); + png_read_info (png_ptr, info_ptr); /* read all PNG info up to image data */ + + png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL); + if ((color_type == PNG_COLOR_TYPE_RGB) || (color_type == PNG_COLOR_TYPE_RGB_ALPHA) + || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) { + im = gdImageCreateTrueColor ((int) width, (int) height); + } else { + im = gdImageCreate ((int) width, (int) height); + } + if (im == NULL) { + gd_error("gd-png error: cannot allocate gdImage struct\n"); + png_destroy_read_struct (&png_ptr, &info_ptr, NULL); + + return NULL; + } + + if (bit_depth == 16) { + png_set_strip_16 (png_ptr); + } else if (bit_depth < 8) { + png_set_packing (png_ptr); /* expand to 1 byte per pixel */ + } + + /* setjmp() must be called in every non-callback function that calls a + * PNG-reading libpng function + */ +#ifdef PNG_SETJMP_SUPPORTED + if (setjmp(jbw.jmpbuf)) { + gd_error("gd-png error: setjmp returns error condition 2\n"); + png_destroy_read_struct(&png_ptr, &info_ptr, NULL); + gdFree(image_data); + gdFree(row_pointers); + if (im) { + gdImageDestroy(im); + } + return NULL; + } +#endif + +#ifdef PNG_pHYs_SUPPORTED + /* check if the resolution is specified */ + if (png_get_valid(png_ptr, info_ptr, PNG_INFO_pHYs)) { + if (png_get_pHYs(png_ptr, info_ptr, &res_x, &res_y, &unit_type)) { + switch (unit_type) { + case PNG_RESOLUTION_METER: + im->res_x = DPM2DPI(res_x); + im->res_y = DPM2DPI(res_y); + break; + } + } + } +#endif + + switch (color_type) { + case PNG_COLOR_TYPE_PALETTE: + png_get_PLTE (png_ptr, info_ptr, &palette, &num_palette); +#ifdef DEBUG + gd_error("gd-png color_type is palette, colors: %d\n", num_palette); +#endif /* DEBUG */ + if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS)) { + /* gd 2.0: we support this rather thoroughly now. Grab the + * first fully transparent entry, if any, as the value of + * the simple-transparency index, mostly for backwards + * binary compatibility. The alpha channel is where it's + * really at these days. + */ + int firstZero = 1; + png_get_tRNS (png_ptr, info_ptr, &trans, &num_trans, NULL); + for (i = 0; i < num_trans; ++i) { + im->alpha[i] = gdAlphaMax - (trans[i] >> 1); + if ((trans[i] == 0) && (firstZero)) { + /* 2.0.5: long-forgotten patch from Wez Furlong */ + transparent = i; + firstZero = 0; + } + } + } + break; + + case PNG_COLOR_TYPE_GRAY: + /* create a fake palette and check for single-shade transparency */ + if ((palette = (png_colorp) gdMalloc (256 * sizeof (png_color))) == NULL) { + gd_error("gd-png error: cannot allocate gray palette\n"); + png_destroy_read_struct (&png_ptr, &info_ptr, NULL); + gdImageDestroy(im); + return NULL; + } + palette_allocated = TRUE; + if (bit_depth < 8) { + num_palette = 1 << bit_depth; + for (i = 0; i < 256; ++i) { + j = (255 * i) / (num_palette - 1); + palette[i].red = palette[i].green = palette[i].blue = j; + } + } else { + num_palette = 256; + for (i = 0; i < 256; ++i) { + palette[i].red = palette[i].green = palette[i].blue = i; + } + } + if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS)) { + png_get_tRNS (png_ptr, info_ptr, NULL, NULL, &trans_gray_rgb); + if (bit_depth == 16) { /* png_set_strip_16() not yet in effect */ + transparent = trans_gray_rgb->gray >> 8; + } else { + transparent = trans_gray_rgb->gray; + } + /* Note slight error in 16-bit case: up to 256 16-bit shades + * may get mapped to a single 8-bit shade, and only one of them + * is supposed to be transparent. IOW, both opaque pixels and + * transparent pixels will be mapped into the transparent entry. + * There is no particularly good way around this in the case + * that all 256 8-bit shades are used, but one could write some + * custom 16-bit code to handle the case where there are gdFree + * palette entries. This error will be extremely rare in + * general, though. (Quite possibly there is only one such + * image in existence.) */ + } + break; + + case PNG_COLOR_TYPE_GRAY_ALPHA: + png_set_gray_to_rgb(png_ptr); + + case PNG_COLOR_TYPE_RGB: + case PNG_COLOR_TYPE_RGB_ALPHA: + /* gd 2.0: we now support truecolor. See the comment above + for a rare situation in which the transparent pixel may not + work properly with 16-bit channels. */ + if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS)) { + png_get_tRNS (png_ptr, info_ptr, NULL, NULL, &trans_color_rgb); + if (bit_depth == 16) { /* png_set_strip_16() not yet in effect */ + transparent = gdTrueColor (trans_color_rgb->red >> 8, + trans_color_rgb->green >> 8, + trans_color_rgb->blue >> 8); + } else { + transparent = gdTrueColor (trans_color_rgb->red, + trans_color_rgb->green, + trans_color_rgb->blue); + } + } + break; + default: + gd_error("gd-png color_type is unknown: %d\n", color_type); + png_destroy_read_struct(&png_ptr, &info_ptr, NULL); + gdFree(image_data); + gdFree(row_pointers); + if (im) { + gdImageDestroy(im); + } + return NULL; + break; + } + + png_read_update_info (png_ptr, info_ptr); + + /* allocate space for the PNG image data */ + rowbytes = png_get_rowbytes (png_ptr, info_ptr); + if (overflow2(rowbytes, height)) { + png_destroy_read_struct (&png_ptr, &info_ptr, NULL); + if (im) { + gdImageDestroy(im); + } + return NULL; + } + image_data = (png_bytep) gdMalloc (rowbytes * height); + if (!image_data) { + gd_error("gd-png error: cannot allocate image data\n"); + png_destroy_read_struct (&png_ptr, &info_ptr, NULL); + if (im) { + gdImageDestroy(im); + } + if (palette_allocated) { + gdFree (palette); + } + return NULL; + } + if (overflow2(height, sizeof (png_bytep))) { + png_destroy_read_struct (&png_ptr, &info_ptr, NULL); + gdFree (image_data); + if (im) { + gdImageDestroy(im); + } + if (palette_allocated) { + gdFree (palette); + } + return NULL; + } + + row_pointers = (png_bytepp) gdMalloc (height * sizeof (png_bytep)); + if (!row_pointers) { + gd_error("gd-png error: cannot allocate row pointers\n"); + png_destroy_read_struct (&png_ptr, &info_ptr, NULL); + if (im) { + gdImageDestroy(im); + } + gdFree (image_data); + if (palette_allocated) { + gdFree (palette); + } + return NULL; + } + + /* set the individual row_pointers to point at the correct offsets */ + for (h = 0; h < height; ++h) { + row_pointers[h] = image_data + h * rowbytes; + } + + png_read_image (png_ptr, row_pointers); /* read whole image... */ + png_read_end (png_ptr, NULL); /* ...done! */ + + if (!im->trueColor) { + im->colorsTotal = num_palette; + /* load the palette and mark all entries "open" (unused) for now */ + open = im->open; + for (i = 0; i < num_palette; ++i) { + im->red[i] = palette[i].red; + im->green[i] = palette[i].green; + im->blue[i] = palette[i].blue; + open[i] = 1; + } + for (i = num_palette; i < gdMaxColors; ++i) { + open[i] = 1; + } + } + /* 2.0.12: Slaven Rezic: palette images are not the only images + with a simple transparent color setting */ + im->transparent = transparent; + im->interlace = (interlace_type == PNG_INTERLACE_ADAM7); + + /* can't nuke structs until done with palette */ + png_destroy_read_struct (&png_ptr, &info_ptr, NULL); + switch (color_type) { + case PNG_COLOR_TYPE_RGB: + for (h = 0; h < height; h++) { + int boffset = 0; + for (w = 0; w < width; w++) { + register png_byte r = row_pointers[h][boffset++]; + register png_byte g = row_pointers[h][boffset++]; + register png_byte b = row_pointers[h][boffset++]; + im->tpixels[h][w] = gdTrueColor (r, g, b); + } + } + break; + + case PNG_COLOR_TYPE_GRAY_ALPHA: + case PNG_COLOR_TYPE_RGB_ALPHA: + for (h = 0; h < height; h++) { + int boffset = 0; + for (w = 0; w < width; w++) { + register png_byte r = row_pointers[h][boffset++]; + register png_byte g = row_pointers[h][boffset++]; + register png_byte b = row_pointers[h][boffset++]; + + /* gd has only 7 bits of alpha channel resolution, and + * 127 is transparent, 0 opaque. A moment of convenience, + * a lifetime of compatibility. + */ + + register png_byte a = gdAlphaMax - (row_pointers[h][boffset++] >> 1); + im->tpixels[h][w] = gdTrueColorAlpha(r, g, b, a); + } + } + break; + default: + /* Palette image, or something coerced to be one */ + for (h = 0; h < height; ++h) { + for (w = 0; w < width; ++w) { + register png_byte idx = row_pointers[h][w]; + im->pixels[h][w] = idx; + open[idx] = 0; + } + } + } +#ifdef DEBUG + if (!im->trueColor) { + for (i = num_palette; i < gdMaxColors; ++i) { + if (!open[i]) { + fprintf (stderr, + "gd-png warning: image data references out-of-range" + " color index (%d)\n", i); + } + } + } +#endif + + if (palette_allocated) { + gdFree (palette); + } + gdFree (image_data); + gdFree (row_pointers); + + return im; +} + + +/* + Function: gdImagePngEx + + <gdImagePngEx> outputs the specified image to the specified file in + PNG format. The file must be open for writing. Under MSDOS and all + versions of Windows, it is important to use "wb" as opposed to + simply "w" as the mode when opening the file, and under Unix there + is no penalty for doing so. <gdImagePngEx> does not close the file; + your code must do so. + + In addition, <gdImagePngEx> allows the level of compression to be + specified. A compression level of 0 means "no compression." A + compression level of 1 means "compressed, but as quickly as + possible." A compression level of 9 means "compressed as much as + possible to produce the smallest possible file." A compression level + of -1 will use the default compression level at the time zlib was + compiled on your system. + + Variants: + + <gdImagePng> is equivalent to calling <gdImagePngEx> with + compression of -1. + + <gdImagePngCtx> and <gdImagePngCtxEx> write via a <gdIOCtx> + instead of a file handle. + + <gdImagePngPtr> and <gdImagePngPtrEx> store the image file to + memory. + + Parameters: + + im - the image to write + outFile - the output FILE* object. + level - compression level: 0 -> none, 1-9 -> level, -1 -> default + + Returns: + + Nothing. + + Example: + + > gdImagePtr im; + > int black, white; + > FILE *out; + > + > im = gdImageCreate(100, 100); // Create the image + > white = gdImageColorAllocate(im, 255, 255, 255); // Alloc background + > black = gdImageColorAllocate(im, 0, 0, 0); // Allocate drawing color + > gdImageRectangle(im, 0, 0, 99, 99, black); // Draw rectangle + > out = fopen("rect.png", "wb"); // Open output file (binary) + > gdImagePngEx(im, out, 9); // Write PNG, max compression + > fclose(out); // Close file + > gdImageDestroy(im); // Destroy image + +*/ +BGD_DECLARE(void) gdImagePngEx (gdImagePtr im, FILE * outFile, int level) +{ + gdIOCtx *out = gdNewFileCtx (outFile); + if (out == NULL) return; + gdImagePngCtxEx (im, out, level); + out->gd_free (out); +} + +/* + Function: gdImagePng + + Equivalent to calling <gdImagePngEx> with compression of -1. + + Parameters: + + im - the image to save. + outFile - the output FILE*. + + Returns: + + Nothing. +*/ +BGD_DECLARE(void) gdImagePng (gdImagePtr im, FILE * outFile) +{ + gdIOCtx *out = gdNewFileCtx (outFile); + if (out == NULL) return; + gdImagePngCtxEx (im, out, -1); + out->gd_free (out); +} + + +/* + Function: gdImagePngPtr + + Equivalent to calling <gdImagePngPtrEx> with compression of -1. + + See <gdImagePngEx> for more information. + + Parameters: + + im - the image to save. + size - Output: size in bytes of the result. + + Returns: + + A pointer to memory containing the image data or NULL on error. + +*/ +BGD_DECLARE(void *) gdImagePngPtr (gdImagePtr im, int *size) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx (2048, NULL); + if (out == NULL) return NULL; + gdImagePngCtxEx (im, out, -1); + rv = gdDPExtractData (out, size); + out->gd_free (out); + return rv; +} + +/* + Function: gdImagePngPtrEx + + Identical to <gdImagePngEx> except that it returns a pointer to a + memory area with the PNG data. This memory must be freed by the + caller when it is no longer needed. **The caller must invoke + gdFree(), not free()** + + The 'size' parameter receives the total size of the block of + memory. + + See <gdImagePngEx> for more information. + + Parameters: + + im - the image to save. + size - Output: size in bytes of the result. + level - compression level: 0 -> none, 1-9 -> level, -1 -> default + + Returns: + + A pointer to memory containing the image data or NULL on error. + +*/ +BGD_DECLARE(void *) gdImagePngPtrEx (gdImagePtr im, int *size, int level) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx (2048, NULL); + if (out == NULL) return NULL; + gdImagePngCtxEx (im, out, level); + rv = gdDPExtractData (out, size); + out->gd_free (out); + return rv; +} + + + +/* + Function: gdImagePngCtx + + Equivalent to calling <gdImagePngCtxEx> with compression of -1. + See <gdImagePngEx> for more information. + + Parameters: + + im - the image to save. + outfile - the <gdIOCtx> to write to. + + Returns: + + Nothing. + +*/ +BGD_DECLARE(void) gdImagePngCtx (gdImagePtr im, gdIOCtx * outfile) +{ + /* 2.0.13: 'return' here was an error, thanks to Kevin Smith */ + gdImagePngCtxEx (im, outfile, -1); +} + + + + +/* + Function: gdImagePngCtxEx + + Outputs the given image as PNG data, but using a <gdIOCtx> instead + of a file. See <gdIamgePnEx>. + + Parameters: + + im - the image to save. + outfile - the <gdIOCtx> to write to. + level - compression level: 0 -> none, 1-9 -> level, -1 -> default + + Returns: + + Nothing. + +*/ + +/* This routine is based in part on code from Dale Lutz (Safe Software Inc.) + * and in part on demo code from Chapter 15 of "PNG: The Definitive Guide" + * (http://www.libpng.org/pub/png/book/). + */ +BGD_DECLARE(void) gdImagePngCtxEx (gdImagePtr im, gdIOCtx * outfile, int level) +{ + int i, j, bit_depth = 0, interlace_type; + int width = im->sx; + int height = im->sy; + int colors = im->colorsTotal; + int *open = im->open; + int mapping[gdMaxColors]; /* mapping[gd_index] == png_index */ + png_byte trans_values[256]; + png_color_16 trans_rgb_value; + png_color palette[gdMaxColors]; + png_structp png_ptr; + png_infop info_ptr; + volatile int transparent = im->transparent; + volatile int remap = FALSE; +#ifdef PNG_SETJMP_SUPPORTED + jmpbuf_wrapper jbw; +#endif + + /* width or height of value 0 is invalid in IHDR; + see http://www.w3.org/TR/PNG-Chunks.html */ + if (width == 0 || height ==0) return; + +#ifdef PNG_SETJMP_SUPPORTED + png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, + &jbw, gdPngErrorHandler, + NULL); +#else + png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); +#endif + if (png_ptr == NULL) { + gd_error("gd-png error: cannot allocate libpng main struct\n"); + return; + } + + info_ptr = png_create_info_struct (png_ptr); + if (info_ptr == NULL) { + gd_error("gd-png error: cannot allocate libpng info struct\n"); + png_destroy_write_struct (&png_ptr, (png_infopp) NULL); + return; + } + +#ifdef PNG_SETJMP_SUPPORTED + if (setjmp(jbw.jmpbuf)) { + gd_error("gd-png error: setjmp returns error condition\n"); + png_destroy_write_struct (&png_ptr, &info_ptr); + return; + } +#endif + + png_set_write_fn (png_ptr, (void *) outfile, gdPngWriteData, + gdPngFlushData); + + /* This is best for palette images, and libpng defaults to it for + palette images anyway, so we don't need to do it explicitly. + What to ideally do for truecolor images depends, alas, on the image. + gd is intentionally imperfect and doesn't spend a lot of time + fussing with such things. */ + + /* Faster if this is uncommented, but may produce larger truecolor files. + Wait for gdImagePngCtxEx. */ +#if 0 + png_set_filter (png_ptr, 0, PNG_FILTER_NONE); +#endif + + /* 2.0.12: this is finally a parameter */ + png_set_compression_level (png_ptr, level); + +#ifdef PNG_pHYs_SUPPORTED + /* 2.1.0: specify the resolution */ + png_set_pHYs(png_ptr, info_ptr, DPI2DPM(im->res_x), DPI2DPM(im->res_y), + PNG_RESOLUTION_METER); +#endif + + /* can set this to a smaller value without compromising compression if all + * image data is 16K or less; will save some decoder memory [min == 8] */ + /* png_set_compression_window_bits(png_ptr, 15); */ + + if (!im->trueColor) { + if (transparent >= im->colorsTotal || + (transparent >= 0 && open[transparent])) + transparent = -1; + } + if (!im->trueColor) { + for (i = 0; i < gdMaxColors; ++i) + mapping[i] = -1; + } + if (!im->trueColor) { + /* count actual number of colors used (colorsTotal == high-water mark) */ + colors = 0; + for (i = 0; i < im->colorsTotal; ++i) { + if (!open[i]) { + mapping[i] = colors; + ++colors; + } + } + if (colors == 0) { + gd_error("gd-png error: no colors in palette\n"); + goto bail; + } + if (colors < im->colorsTotal) { + remap = TRUE; + } + if (colors <= 2) + bit_depth = 1; + else if (colors <= 4) + bit_depth = 2; + else if (colors <= 16) + bit_depth = 4; + else + bit_depth = 8; + } + interlace_type = im->interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE; + + if (im->trueColor) { + if (im->saveAlphaFlag) { + png_set_IHDR (png_ptr, info_ptr, width, height, 8, + PNG_COLOR_TYPE_RGB_ALPHA, interlace_type, + PNG_COMPRESSION_TYPE_DEFAULT, + PNG_FILTER_TYPE_DEFAULT); + } else { + png_set_IHDR (png_ptr, info_ptr, width, height, 8, + PNG_COLOR_TYPE_RGB, interlace_type, + PNG_COMPRESSION_TYPE_DEFAULT, + PNG_FILTER_TYPE_DEFAULT); + } + } else { + png_set_IHDR (png_ptr, info_ptr, width, height, bit_depth, + PNG_COLOR_TYPE_PALETTE, interlace_type, + PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); + } + if (im->trueColor && (!im->saveAlphaFlag) && (transparent >= 0)) { + /* 2.0.9: fixed by Thomas Winzig */ + trans_rgb_value.red = gdTrueColorGetRed (im->transparent); + trans_rgb_value.green = gdTrueColorGetGreen (im->transparent); + trans_rgb_value.blue = gdTrueColorGetBlue (im->transparent); + png_set_tRNS (png_ptr, info_ptr, 0, 0, &trans_rgb_value); + } + if (!im->trueColor) { + /* Oy veh. Remap the PNG palette to put the + entries with interesting alpha channel + values first. This minimizes the size + of the tRNS chunk and thus the size + of the PNG file as a whole. */ + int tc = 0; + int i; + int j; + int k; + for (i = 0; (i < im->colorsTotal); i++) { + if ((!im->open[i]) && (im->alpha[i] != gdAlphaOpaque)) { + tc++; + } + } + if (tc) { +#if 0 + for (i = 0; (i < im->colorsTotal); i++) { + trans_values[i] = 255 - + ((im->alpha[i] << 1) + (im->alpha[i] >> 6)); + } + png_set_tRNS (png_ptr, info_ptr, trans_values, 256, NULL); +#endif + if (!remap) { + remap = TRUE; + } + /* (Semi-)transparent indexes come up from the bottom + of the list of real colors; opaque + indexes come down from the top */ + j = 0; + k = colors - 1; + for (i = 0; (i < im->colorsTotal); i++) { + if (!im->open[i]) { + if (im->alpha[i] != gdAlphaOpaque) { + /* Andrew Hull: >> 6, not >> 7! (gd 2.0.5) */ + trans_values[j] = 255 - + ((im->alpha[i] << 1) + (im->alpha[i] >> 6)); + mapping[i] = j++; + } else { + mapping[i] = k--; + } + } + } + png_set_tRNS (png_ptr, info_ptr, trans_values, tc, NULL); + } + } + + /* convert palette to libpng layout */ + if (!im->trueColor) { + if (remap) + for (i = 0; i < im->colorsTotal; ++i) { + if (mapping[i] < 0) + continue; + palette[mapping[i]].red = im->red[i]; + palette[mapping[i]].green = im->green[i]; + palette[mapping[i]].blue = im->blue[i]; + } + else + for (i = 0; i < colors; ++i) { + palette[i].red = im->red[i]; + palette[i].green = im->green[i]; + palette[i].blue = im->blue[i]; + } + png_set_PLTE (png_ptr, info_ptr, palette, colors); + } + + /* write out the PNG header info (everything up to first IDAT) */ + png_write_info (png_ptr, info_ptr); + + /* make sure < 8-bit images are packed into pixels as tightly as possible */ + png_set_packing (png_ptr); + + /* This code allocates a set of row buffers and copies the gd image data + * into them only in the case that remapping is necessary; in gd 1.3 and + * later, the im->pixels array is laid out identically to libpng's row + * pointers and can be passed to png_write_image() function directly. + * The remapping case could be accomplished with less memory for non- + * interlaced images, but interlacing causes some serious complications. */ + if (im->trueColor) { + /* performance optimizations by Phong Tran */ + int channels = im->saveAlphaFlag ? 4 : 3; + /* Our little 7-bit alpha channel trick costs us a bit here. */ + png_bytep *row_pointers; + unsigned char *pOutputRow; + int **ptpixels = im->tpixels; + int *pThisRow; + unsigned char a; + int thisPixel; + png_bytep *prow_pointers; + int saveAlphaFlag = im->saveAlphaFlag; + if (overflow2(sizeof (png_bytep), height)) { + goto bail; + } + row_pointers = gdMalloc (sizeof (png_bytep) * height); + if (row_pointers == NULL) { + gd_error("gd-png error: unable to allocate row_pointers\n"); + goto bail; + } + prow_pointers = row_pointers; + for (j = 0; j < height; ++j) { + if (overflow2(width, channels) || ((*prow_pointers = + (png_bytep) gdMalloc (width * channels)) == NULL)) { + gd_error("gd-png error: unable to allocate rows\n"); + for (i = 0; i < j; ++i) + gdFree (row_pointers[i]); + /* 2.0.29: memory leak TBB */ + gdFree(row_pointers); + goto bail; + } + pOutputRow = *prow_pointers++; + pThisRow = *ptpixels++; + for (i = 0; i < width; ++i) { + thisPixel = *pThisRow++; + *pOutputRow++ = gdTrueColorGetRed (thisPixel); + *pOutputRow++ = gdTrueColorGetGreen (thisPixel); + *pOutputRow++ = gdTrueColorGetBlue (thisPixel); + + if (saveAlphaFlag) { + /* convert the 7-bit alpha channel to an 8-bit alpha channel. + We do a little bit-flipping magic, repeating the MSB + as the LSB, to ensure that 0 maps to 0 and + 127 maps to 255. We also have to invert to match + PNG's convention in which 255 is opaque. */ + a = gdTrueColorGetAlpha (thisPixel); + /* Andrew Hull: >> 6, not >> 7! (gd 2.0.5) */ + *pOutputRow++ = 255 - ((a << 1) + (a >> 6)); + } + } + } + + png_write_image (png_ptr, row_pointers); + png_write_end (png_ptr, info_ptr); + + for (j = 0; j < height; ++j) + gdFree (row_pointers[j]); + gdFree (row_pointers); + } else { + if (remap) { + png_bytep *row_pointers; + if (overflow2(sizeof (png_bytep), height)) { + goto bail; + } + row_pointers = gdMalloc (sizeof (png_bytep) * height); + if (row_pointers == NULL) { + gd_error("gd-png error: unable to allocate row_pointers\n"); + goto bail; + } + for (j = 0; j < height; ++j) { + if ((row_pointers[j] = (png_bytep) gdMalloc (width)) == NULL) { + gd_error("gd-png error: unable to allocate rows\n"); + for (i = 0; i < j; ++i) + gdFree (row_pointers[i]); + /* TBB: memory leak */ + gdFree (row_pointers); + goto bail; + } + for (i = 0; i < width; ++i) + row_pointers[j][i] = mapping[im->pixels[j][i]]; + } + + png_write_image (png_ptr, row_pointers); + png_write_end (png_ptr, info_ptr); + + for (j = 0; j < height; ++j) + gdFree (row_pointers[j]); + gdFree (row_pointers); + } else { + png_write_image (png_ptr, im->pixels); + png_write_end (png_ptr, info_ptr); + } + } + /* 1.6.3: maybe we should give that memory BACK! TBB */ +bail: + png_destroy_write_struct (&png_ptr, &info_ptr); +} + + +#endif /* HAVE_LIBPNG */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_rotate.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_rotate.c new file mode 100644 index 00000000000..eb057e1148e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_rotate.c @@ -0,0 +1,533 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif /* HAVE_CONFIG_H */ + +#include "gd.h" +#include "gd_intern.h" +#include <math.h> + +/* + * Rotate function Added on 2003/12 + * by Pierre-Alain Joye (pierre@php.net) + **/ +/* Begin rotate function */ +#ifdef ROTATE_PI +#undef ROTATE_PI +#endif /* ROTATE_PI */ + +typedef int (BGD_STDCALL *FuncPtr)(gdImagePtr, int, int); + +#define ROTATE_DEG2RAD 3.1415926535897932384626433832795/180 +void gdImageSkewX (gdImagePtr dst, gdImagePtr src, int uRow, int iOffset, double dWeight, int clrBack, int ignoretransparent) +{ + int i, r, g, b, a, clrBackR, clrBackG, clrBackB, clrBackA; + FuncPtr f; + + int pxlOldLeft, pxlLeft=0, pxlSrc; + + /* Keep clrBack as color index if required */ + if (src->trueColor) { + pxlOldLeft = clrBack; + f = gdImageGetTrueColorPixel; + } else { + pxlOldLeft = clrBack; + clrBackR = gdImageRed(src, clrBack); + clrBackG = gdImageGreen(src, clrBack); + clrBackB = gdImageBlue(src, clrBack); + clrBackA = gdImageAlpha(src, clrBack); + clrBack = gdTrueColorAlpha(clrBackR, clrBackG, clrBackB, clrBackA); + f = gdImageGetPixel; + } + + for (i = 0; i < iOffset; i++) { + gdImageSetPixel (dst, i, uRow, clrBack); + } + + if (i < dst->sx) { + gdImageSetPixel (dst, i, uRow, clrBack); + } + + for (i = 0; i < src->sx; i++) { + pxlSrc = f (src,i,uRow); + + r = (int)(gdImageRed(src,pxlSrc) * dWeight); + g = (int)(gdImageGreen(src,pxlSrc) * dWeight); + b = (int)(gdImageBlue(src,pxlSrc) * dWeight); + a = (int)(gdImageAlpha(src,pxlSrc) * dWeight); + + pxlLeft = gdImageColorAllocateAlpha(src, r, g, b, a); + + if (pxlLeft == -1) { + pxlLeft = gdImageColorClosestAlpha(src, r, g, b, a); + } + + r = gdImageRed(src,pxlSrc) - (gdImageRed(src,pxlLeft) - gdImageRed(src,pxlOldLeft)); + g = gdImageGreen(src,pxlSrc) - (gdImageGreen(src,pxlLeft) - gdImageGreen(src,pxlOldLeft)); + b = gdImageBlue(src,pxlSrc) - (gdImageBlue(src,pxlLeft) - gdImageBlue(src,pxlOldLeft)); + a = gdImageAlpha(src,pxlSrc) - (gdImageAlpha(src,pxlLeft) - gdImageAlpha(src,pxlOldLeft)); + + if (r>255) { + r = 255; + } + + if (g>255) { + g = 255; + } + + if (b>255) { + b = 255; + } + + if (a>127) { + a = 127; + } + + if (ignoretransparent && pxlSrc == dst->transparent) { + pxlSrc = dst->transparent; + } else { + pxlSrc = gdImageColorAllocateAlpha(dst, r, g, b, a); + + if (pxlSrc == -1) { + pxlSrc = gdImageColorClosestAlpha(dst, r, g, b, a); + } + } + + if ((i + iOffset >= 0) && (i + iOffset < dst->sx)) { + gdImageSetPixel (dst, i+iOffset, uRow, pxlSrc); + } + + pxlOldLeft = pxlLeft; + } + + i += iOffset; + + if (i < dst->sx) { + gdImageSetPixel (dst, i, uRow, pxlLeft); + } + + gdImageSetPixel (dst, iOffset, uRow, clrBack); + + i--; + + while (++i < dst->sx) { + gdImageSetPixel (dst, i, uRow, clrBack); + } +} + +void gdImageSkewY (gdImagePtr dst, gdImagePtr src, int uCol, int iOffset, double dWeight, int clrBack, int ignoretransparent) +{ + int i, iYPos=0, r, g, b, a; + FuncPtr f; + int pxlOldLeft, pxlLeft=0, pxlSrc; + + if (src->trueColor) { + f = gdImageGetTrueColorPixel; + } else { + f = gdImageGetPixel; + } + + for (i = 0; i<=iOffset; i++) { + gdImageSetPixel (dst, uCol, i, clrBack); + } + r = (int)((double)gdImageRed(src,clrBack) * dWeight); + g = (int)((double)gdImageGreen(src,clrBack) * dWeight); + b = (int)((double)gdImageBlue(src,clrBack) * dWeight); + a = (int)((double)gdImageAlpha(src,clrBack) * dWeight); + + pxlOldLeft = gdImageColorAllocateAlpha(dst, r, g, b, a); + + for (i = 0; i < src->sy; i++) { + pxlSrc = f (src, uCol, i); + iYPos = i + iOffset; + + r = (int)((double)gdImageRed(src,pxlSrc) * dWeight); + g = (int)((double)gdImageGreen(src,pxlSrc) * dWeight); + b = (int)((double)gdImageBlue(src,pxlSrc) * dWeight); + a = (int)((double)gdImageAlpha(src,pxlSrc) * dWeight); + + pxlLeft = gdImageColorAllocateAlpha(src, r, g, b, a); + + if (pxlLeft == -1) { + pxlLeft = gdImageColorClosestAlpha(src, r, g, b, a); + } + + r = gdImageRed(src,pxlSrc) - (gdImageRed(src,pxlLeft) - gdImageRed(src,pxlOldLeft)); + g = gdImageGreen(src,pxlSrc) - (gdImageGreen(src,pxlLeft) - gdImageGreen(src,pxlOldLeft)); + b = gdImageBlue(src,pxlSrc) - (gdImageBlue(src,pxlLeft) - gdImageBlue(src,pxlOldLeft)); + a = gdImageAlpha(src,pxlSrc) - (gdImageAlpha(src,pxlLeft) - gdImageAlpha(src,pxlOldLeft)); + + if (r>255) { + r = 255; + } + + if (g>255) { + g = 255; + } + + if (b>255) { + b = 255; + } + + if (a>127) { + a = 127; + } + + if (ignoretransparent && pxlSrc == dst->transparent) { + pxlSrc = dst->transparent; + } else { + pxlSrc = gdImageColorAllocateAlpha(dst, r, g, b, a); + + if (pxlSrc == -1) { + pxlSrc = gdImageColorClosestAlpha(dst, r, g, b, a); + } + } + + if ((iYPos >= 0) && (iYPos < dst->sy)) { + gdImageSetPixel (dst, uCol, iYPos, pxlSrc); + } + + pxlOldLeft = pxlLeft; + } + + i = iYPos; + if (i < dst->sy) { + gdImageSetPixel (dst, uCol, i, pxlLeft); + } + + i--; + while (++i < dst->sy) { + gdImageSetPixel (dst, uCol, i, clrBack); + } +} + +/* Rotates an image by 90 degrees (counter clockwise) */ +gdImagePtr gdImageRotate90 (gdImagePtr src, int ignoretransparent) +{ + int uY, uX; + int c,r,g,b,a; + gdImagePtr dst; + FuncPtr f; + + if (src->trueColor) { + f = gdImageGetTrueColorPixel; + } else { + f = gdImageGetPixel; + } + dst = gdImageCreateTrueColor(src->sy, src->sx); + if (dst != NULL) { + int old_blendmode = dst->alphaBlendingFlag; + dst->alphaBlendingFlag = 0; + + dst->transparent = src->transparent; + + gdImagePaletteCopy (dst, src); + + for (uY = 0; uY<src->sy; uY++) { + for (uX = 0; uX<src->sx; uX++) { + c = f (src, uX, uY); + if (!src->trueColor) { + r = gdImageRed(src,c); + g = gdImageGreen(src,c); + b = gdImageBlue(src,c); + a = gdImageAlpha(src,c); + c = gdTrueColorAlpha(r, g, b, a); + } + if (ignoretransparent && c == dst->transparent) { + gdImageSetPixel(dst, uY, (dst->sy - uX - 1), dst->transparent); + } else { + gdImageSetPixel(dst, uY, (dst->sy - uX - 1), c); + } + } + } + dst->alphaBlendingFlag = old_blendmode; + } + + return dst; +} + +/* Rotates an image by 180 degrees (counter clockwise) */ +gdImagePtr gdImageRotate180 (gdImagePtr src, int ignoretransparent) +{ + int uY, uX; + int c,r,g,b,a; + gdImagePtr dst; + FuncPtr f; + + if (src->trueColor) { + f = gdImageGetTrueColorPixel; + } else { + f = gdImageGetPixel; + } + dst = gdImageCreateTrueColor(src->sx, src->sy); + + if (dst != NULL) { + int old_blendmode = dst->alphaBlendingFlag; + dst->alphaBlendingFlag = 0; + + dst->transparent = src->transparent; + + gdImagePaletteCopy (dst, src); + + for (uY = 0; uY<src->sy; uY++) { + for (uX = 0; uX<src->sx; uX++) { + c = f (src, uX, uY); + if (!src->trueColor) { + r = gdImageRed(src,c); + g = gdImageGreen(src,c); + b = gdImageBlue(src,c); + a = gdImageAlpha(src,c); + c = gdTrueColorAlpha(r, g, b, a); + } + + if (ignoretransparent && c == dst->transparent) { + gdImageSetPixel(dst, (dst->sx - uX - 1), (dst->sy - uY - 1), dst->transparent); + } else { + gdImageSetPixel(dst, (dst->sx - uX - 1), (dst->sy - uY - 1), c); + } + } + } + dst->alphaBlendingFlag = old_blendmode; + } + + return dst; +} + +/* Rotates an image by 270 degrees (counter clockwise) */ +gdImagePtr gdImageRotate270 (gdImagePtr src, int ignoretransparent) +{ + int uY, uX; + int c,r,g,b,a; + gdImagePtr dst; + FuncPtr f; + + if (src->trueColor) { + f = gdImageGetTrueColorPixel; + } else { + f = gdImageGetPixel; + } + dst = gdImageCreateTrueColor (src->sy, src->sx); + + if (dst != NULL) { + int old_blendmode = dst->alphaBlendingFlag; + dst->alphaBlendingFlag = 0; + + dst->transparent = src->transparent; + + gdImagePaletteCopy (dst, src); + + for (uY = 0; uY<src->sy; uY++) { + for (uX = 0; uX<src->sx; uX++) { + c = f (src, uX, uY); + if (!src->trueColor) { + r = gdImageRed(src,c); + g = gdImageGreen(src,c); + b = gdImageBlue(src,c); + a = gdImageAlpha(src,c); + c = gdTrueColorAlpha(r, g, b, a); + } + + if (ignoretransparent && c == dst->transparent) { + gdImageSetPixel(dst, (dst->sx - uY - 1), uX, dst->transparent); + } else { + gdImageSetPixel(dst, (dst->sx - uY - 1), uX, c); + } + } + } + dst->alphaBlendingFlag = old_blendmode; + } + + return dst; +} + +gdImagePtr gdImageRotate45 (gdImagePtr src, double dAngle, int clrBack, int ignoretransparent) +{ + gdImagePtr dst1,dst2,dst3; + double dRadAngle, dSinE, dTan, dShear; + double dOffset; /* Variable skew offset */ + int u, iShear, newx, newy; + int clrBackR, clrBackG, clrBackB, clrBackA; + + /* See GEMS I for the algorithm details */ + dRadAngle = dAngle * ROTATE_DEG2RAD; /* Angle in radians */ + dSinE = sin (dRadAngle); + dTan = tan (dRadAngle / 2.0); + + newx = (int)(src->sx + src->sy * fabs(dTan)); + newy = src->sy; + + /* 1st shear */ + dst1 = gdImageCreateTrueColor(newx, newy); + /******* Perform 1st shear (horizontal) ******/ + if (dst1 == NULL) { + return NULL; + } +#ifdef HAVE_GD_BUNDLED + dst1->alphaBlendingFlag = gdEffectReplace; +#else + gdImageAlphaBlending(dst1, 0); +#endif + if (dAngle == 0.0) { + /* Returns copy of src */ + gdImageCopy (dst1, src,0,0,0,0,src->sx,src->sy); + return dst1; + } + + gdImagePaletteCopy (dst1, src); + + if (ignoretransparent) { + if (gdImageTrueColor(src)) { + dst1->transparent = src->transparent; + } else { + + dst1->transparent = gdTrueColorAlpha(gdImageRed(src, src->transparent), gdImageBlue(src, src->transparent), gdImageGreen(src, src->transparent), 127); + } + } + + for (u = 0; u < dst1->sy; u++) { + if (dTan >= 0.0) { + dShear = ((double)(u + 0.5)) * dTan; + } else { + dShear = ((double)(u - dst1->sy) + 0.5) * dTan; + } + + iShear = (int)floor(dShear); + gdImageSkewX(dst1, src, u, iShear, (dShear - iShear), clrBack, ignoretransparent); + } + + /* + The 1st shear may use the original clrBack as color index + Convert it once here + */ + if(!src->trueColor) { + clrBackR = gdImageRed(src, clrBack); + clrBackG = gdImageGreen(src, clrBack); + clrBackB = gdImageBlue(src, clrBack); + clrBackA = gdImageAlpha(src, clrBack); + clrBack = gdTrueColorAlpha(clrBackR, clrBackG, clrBackB, clrBackA); + } + /* 2nd shear */ + newx = dst1->sx; + + if (dSinE > 0.0) { + dOffset = (src->sx-1) * dSinE; + } else { + dOffset = -dSinE * (src->sx - newx); + } + + newy = (int) ((double) src->sx * fabs( dSinE ) + (double) src->sy * cos (dRadAngle))+1; + + dst2 = gdImageCreateTrueColor(newx, newy); + if (dst2 == NULL) { + gdImageDestroy(dst1); + return NULL; + } + +#ifdef HAVE_GD_BUNDLED + dst2->alphaBlendingFlag = gdEffectReplace; +#else + gdImageAlphaBlending(dst2, 0); +#endif + + if (ignoretransparent) { + dst2->transparent = dst1->transparent; + } + + for (u = 0; u < dst2->sx; u++, dOffset -= dSinE) { + iShear = (int)floor (dOffset); + gdImageSkewY(dst2, dst1, u, iShear, (dOffset - (double)iShear), clrBack, ignoretransparent); + } + + /* 3rd shear */ + gdImageDestroy(dst1); + + newx = (int) ((double)src->sy * fabs (dSinE) + (double)src->sx * cos (dRadAngle)) + 1; + newy = dst2->sy; + + dst3 = gdImageCreateTrueColor(newx, newy); + if (dst3 == NULL) { + gdImageDestroy(dst2); + return NULL; + } + +#ifdef HAVE_GD_BUNDLED + dst3->alphaBlendingFlag = gdEffectReplace; +#else + gdImageAlphaBlending(dst3, 0); +#endif + + if (ignoretransparent) { + dst3->transparent = dst2->transparent; + } + + if (dSinE >= 0.0) { + dOffset = (double)(src->sx - 1) * dSinE * -dTan; + } else { + dOffset = dTan * ((double)(src->sx - 1) * -dSinE + (double)(1 - newy)); + } + + for (u = 0; u < dst3->sy; u++, dOffset += dTan) { + int iShear = (int)floor(dOffset); + gdImageSkewX(dst3, dst2, u, iShear, (dOffset - iShear), clrBack, ignoretransparent); + } + + gdImageDestroy(dst2); + + return dst3; +} + +gdImagePtr gdImageRotate (gdImagePtr src, double dAngle, int clrBack, int ignoretransparent) +{ + gdImagePtr pMidImg; + gdImagePtr rotatedImg; + + if (src == NULL) { + return NULL; + } + + if (!gdImageTrueColor(src) && (clrBack < 0 || clrBack>=gdImageColorsTotal(src))) { + return NULL; + } + + while (dAngle >= 360.0) { + dAngle -= 360.0; + } + + while (dAngle < 0) { + dAngle += 360.0; + } + + if (dAngle == 90.00) { + return gdImageRotate90(src, ignoretransparent); + } + if (dAngle == 180.00) { + return gdImageRotate180(src, ignoretransparent); + } + if(dAngle == 270.00) { + return gdImageRotate270 (src, ignoretransparent); + } + + if ((dAngle > 45.0) && (dAngle <= 135.0)) { + pMidImg = gdImageRotate90 (src, ignoretransparent); + dAngle -= 90.0; + } else if ((dAngle > 135.0) && (dAngle <= 225.0)) { + pMidImg = gdImageRotate180 (src, ignoretransparent); + dAngle -= 180.0; + } else if ((dAngle > 225.0) && (dAngle <= 315.0)) { + pMidImg = gdImageRotate270 (src, ignoretransparent); + dAngle -= 270.0; + } else { + return gdImageRotate45 (src, dAngle, clrBack, ignoretransparent); + } + + if (pMidImg == NULL) { + return NULL; + } + + rotatedImg = gdImageRotate45 (pMidImg, dAngle, clrBack, ignoretransparent); + gdImageDestroy(pMidImg); + + return rotatedImg; +} +/* End Rotate function */ + + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_security.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_security.c new file mode 100644 index 00000000000..0051ebf4559 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_security.c @@ -0,0 +1,32 @@ +/* + * gd_security.c + * + * Implements buffer overflow check routines. + * + * Written 2004, Phil Knirsch. + * Based on netpbm fixes by Alan Cox. + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include <limits.h> +#include "gd.h" +#include "gd_errors.h" + +int overflow2(int a, int b) +{ + if(a <= 0 || b <= 0) { + gd_error_ex(GD_WARNING, "one parameter to a memory allocation multiplication is negative or zero, failing operation gracefully\n"); + return 1; + } + if(a > INT_MAX / b) { + gd_error_ex(GD_WARNING, "product of memory allocation multiplication would exceed INT_MAX, failing operation gracefully\n"); + return 1; + } + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_ss.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_ss.c new file mode 100644 index 00000000000..9098c9bc91c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_ss.c @@ -0,0 +1,59 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include "gd.h" +#include "gd_errors.h" + +#define TRUE 1 +#define FALSE 0 + +/* Use this for commenting out debug-print statements. */ +/* Just use the first '#define' to allow all the prints... */ +/*#define GD_SS_DBG(s) (s) */ +#define GD_SS_DBG(s) + +#ifdef HAVE_LIBPNG +BGD_DECLARE(void) gdImagePngToSink (gdImagePtr im, gdSinkPtr outSink) +{ + gdIOCtx *out = gdNewSSCtx (NULL, outSink); + gdImagePngCtx (im, out); + out->gd_free (out); +} + +/* + Function: gdImageCreateFromPngSource + + See <gdImageCreateFromPng> for documentation. This is obsolete; use + <gdImageCreateFromPngCtx> instead. + */ +BGD_DECLARE(gdImagePtr) gdImageCreateFromPngSource (gdSourcePtr inSource) +{ + gdIOCtx *in = gdNewSSCtx (inSource, NULL); + gdImagePtr im; + + im = gdImageCreateFromPngCtx (in); + + in->gd_free (in); + + return im; +} +#else /* no HAVE_LIBPNG */ +BGD_DECLARE(void) gdImagePngToSink (gdImagePtr im, gdSinkPtr outSink) +{ + (void)im; + (void)outSink; + gd_error("PNG support is not available\n"); +} + +BGD_DECLARE(gdImagePtr) gdImageCreateFromPngSource (gdSourcePtr inSource) +{ + (void)inSource; + gd_error("PNG support is not available\n"); + return NULL; +} +#endif /* HAVE_LIBPNG */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_tga.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_tga.c new file mode 100644 index 00000000000..756248afcea --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_tga.c @@ -0,0 +1,352 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif /* HAVE_CONFIG_H */ + +#include <stdio.h> +#include <stddef.h> +#include <stdlib.h> +#include <string.h> + +#include "gd_tga.h" +#include "gd.h" +#include "gd_errors.h" +#include "gdhelpers.h" + +/*! \brief Creates a gdImage from a TGA file + * Creates a gdImage from a TGA binary file via a gdIOCtx. + * \param infile Pointer to TGA binary file + * \return gdImagePtr + */ +BGD_DECLARE(gdImagePtr) gdImageCreateFromTga(FILE *fp) +{ + gdImagePtr image; + gdIOCtx* in = gdNewFileCtx(fp); + if (in == NULL) return NULL; + image = gdImageCreateFromTgaCtx(in); + in->gd_free( in ); + return image; +} + +BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaPtr(int size, void *data) +{ + gdImagePtr im; + gdIOCtx *in = gdNewDynamicCtxEx (size, data, 0); + if (in == NULL) return NULL; + im = gdImageCreateFromTgaCtx(in); + in->gd_free(in); + return im; +} + + +/*! \brief Creates a gdImage from a gdIOCtx + * Creates a gdImage from a gdIOCtx referencing a TGA binary file. + * \param ctx Pointer to a gdIOCtx structure + * \return gdImagePtr + */ +BGD_DECLARE(gdImagePtr) gdImageCreateFromTgaCtx(gdIOCtx* ctx) +{ + int bitmap_caret = 0; + oTga *tga = NULL; + /* int pixel_block_size = 0; + int image_block_size = 0; */ + volatile gdImagePtr image = NULL; + int x = 0; + int y = 0; + + tga = (oTga *) gdMalloc(sizeof(oTga)); + if (!tga) { + return NULL; + } + + tga->bitmap = NULL; + tga->ident = NULL; + + if (!read_header_tga(ctx, tga)) { + free_tga(tga); + return NULL; + } + + /*TODO: Will this be used? + pixel_block_size = tga->bits / 8; + image_block_size = (tga->width * tga->height) * pixel_block_size; + */ + + if (read_image_tga(ctx, tga)) { + free_tga(tga); + return NULL; + } + + image = gdImageCreateTrueColor((int)tga->width, (int)tga->height ); + + if (image == 0) { + free_tga( tga ); + return NULL; + } + + /*! \brief Populate GD image object + * Copy the pixel data from our tga bitmap buffer into the GD image + * Disable blending and save the alpha channel per default + */ + if (tga->alphabits) { + gdImageAlphaBlending(image, 0); + gdImageSaveAlpha(image, 1); + } + + /* TODO: use alphabits as soon as we support 24bit and other alpha bps (ie != 8bits) */ + for (y = 0; y < tga->height; y++) { + register int *tpix = image->tpixels[y]; + for ( x = 0; x < tga->width; x++, tpix++) { + if (tga->bits == TGA_BPP_24) { + *tpix = gdTrueColor(tga->bitmap[bitmap_caret + 2], tga->bitmap[bitmap_caret + 1], tga->bitmap[bitmap_caret]); + bitmap_caret += 3; + } else if (tga->bits == TGA_BPP_32 || tga->alphabits) { + register int a = tga->bitmap[bitmap_caret + 3]; + + *tpix = gdTrueColorAlpha(tga->bitmap[bitmap_caret + 2], tga->bitmap[bitmap_caret + 1], tga->bitmap[bitmap_caret], gdAlphaMax - (a >> 1)); + bitmap_caret += 4; + } + } + } + + if (tga->flipv && tga->fliph) { + gdImageFlipBoth(image); + } else if (tga->flipv) { + gdImageFlipVertical(image); + } else if (tga->fliph) { + gdImageFlipHorizontal(image); + } + + free_tga(tga); + + return image; +} + +/*! \brief Reads a TGA header. + * Reads the header block from a binary TGA file populating the referenced TGA structure. + * \param ctx Pointer to TGA binary file + * \param tga Pointer to TGA structure + * \return int 1 on sucess, -1 on failure + */ +int read_header_tga(gdIOCtx *ctx, oTga *tga) +{ + + unsigned char header[18]; + + if (gdGetBuf(header, sizeof(header), ctx) < 18) { + gd_error("fail to read header"); + return -1; + } + + tga->identsize = header[0]; + tga->colormaptype = header[1]; + tga->imagetype = header[2]; + tga->colormapstart = header[3] + (header[4] << 8); + tga->colormaplength = header[5] + (header[6] << 8); + tga->colormapbits = header[7]; + tga->xstart = header[8] + (header[9] << 8); + tga->ystart = header[10] + (header[11] << 8); + tga->width = header[12] + (header[13] << 8); + tga->height = header[14] + (header[15] << 8); + tga->bits = header[16]; + tga->alphabits = header[17] & 0x0f; + tga->fliph = (header[17] & 0x10) ? 1 : 0; + tga->flipv = (header[17] & 0x20) ? 0 : 1; + +#if DEBUG + printf("format bps: %i\n", tga->bits); + printf("flip h/v: %i / %i\n", tga->fliph, tga->flipv); + printf("alpha: %i\n", tga->alphabits); + printf("wxh: %i %i\n", tga->width, tga->height); +#endif + + switch(tga->bits) { + case 8: + case 16: + case 24: + case 32: + break; + default: + gd_error("bps %i not supported", tga->bits); + return -1; + break; + } + + tga->ident = NULL; + + if (tga->identsize > 0) { + tga->ident = (char *) gdMalloc(tga->identsize * sizeof(char)); + if(tga->ident == NULL) { + return -1; + } + + gdGetBuf( &( tga->ident ), tga->identsize, ctx ); + } + + return 1; +} + +/*! \brief Reads a TGA image data into buffer. + * Reads the image data block from a binary TGA file populating the referenced TGA structure. + * \param ctx Pointer to TGA binary file + * \param tga Pointer to TGA structure + * \return int 0 on sucess, -1 on failure + */ +int read_image_tga( gdIOCtx *ctx, oTga *tga ) +{ + int pixel_block_size = (tga->bits / 8); + int image_block_size = (tga->width * tga->height) * pixel_block_size; + uint8_t* decompression_buffer = NULL; + unsigned char* conversion_buffer = NULL; + int buffer_caret = 0; + int bitmap_caret = 0; + int i = 0; + int j = 0; + uint8_t encoded_pixels; + + if(overflow2(tga->width, tga->height)) { + return -1; + } + + if(overflow2(tga->width * tga->height, pixel_block_size)) { + return -1; + } + + if(overflow2(image_block_size, sizeof(uint8_t))) { + return -1; + } + + /*! \brief Allocate memmory for image block + * Allocate a chunk of memory for the image block to be passed into. + */ + tga->bitmap = (int *) gdMalloc(image_block_size * sizeof(uint8_t)); + if (tga->bitmap == NULL) { + return -1; + } + + /*! \todo Add image type support + * Add support for this image type. + */ + if (tga->imagetype == TGA_TYPE_INDEXED) { + return -1; + } + + /*! \todo Add image type support + * Add support for this image type. + */ + if (tga->imagetype == TGA_TYPE_INDEXED_RLE) { + return -1; + } + + /*! \brief Read in uncompressed RGB TGA + * Chunk load the pixel data from an uncompressed RGB type TGA. + */ + if (tga->imagetype == TGA_TYPE_RGB) { + conversion_buffer = (unsigned char *) gdMalloc(image_block_size * sizeof(unsigned char)); + if (conversion_buffer == NULL) { + gdFree(conversion_buffer); + return -1; + } + + gdGetBuf(conversion_buffer, image_block_size, ctx); + + while (buffer_caret < image_block_size) { + tga->bitmap[buffer_caret] = (int) conversion_buffer[buffer_caret]; + buffer_caret++; + } + + gdFree( conversion_buffer ); + } + + /*! \brief Read in RLE compressed RGB TGA + * Chunk load the pixel data from an RLE compressed RGB type TGA. + */ + if (tga->imagetype == TGA_TYPE_RGB_RLE) { + decompression_buffer = (uint8_t*) gdMalloc(image_block_size * sizeof(uint8_t)); + if (decompression_buffer == NULL) { + gdFree( decompression_buffer ); + return -1; + } + conversion_buffer = (unsigned char *) gdMalloc(image_block_size * sizeof(unsigned char)); + if (conversion_buffer == NULL) { + gdFree( decompression_buffer ); + gdFree( conversion_buffer ); + return -1; + } + + gdGetBuf( conversion_buffer, image_block_size, ctx ); + + buffer_caret = 0; + + while( buffer_caret < image_block_size ) { + decompression_buffer[buffer_caret] = (int)conversion_buffer[buffer_caret]; + buffer_caret++; + } + + buffer_caret = 0; + + while( bitmap_caret < image_block_size ) { + + if ((decompression_buffer[buffer_caret] & TGA_RLE_FLAG) == TGA_RLE_FLAG) { + encoded_pixels = ( ( decompression_buffer[ buffer_caret ] & 127 ) + 1 ); + buffer_caret++; + + for (i = 0; i < encoded_pixels; i++) { + for (j = 0; j < pixel_block_size; j++, bitmap_caret++) { + tga->bitmap[ bitmap_caret ] = decompression_buffer[ buffer_caret + j ]; + } + } + buffer_caret += pixel_block_size; + } else { + encoded_pixels = decompression_buffer[ buffer_caret ] + 1; + buffer_caret++; + + for (i = 0; i < encoded_pixels; i++) { + for( j = 0; j < pixel_block_size; j++, bitmap_caret++ ) { + tga->bitmap[ bitmap_caret ] = decompression_buffer[ buffer_caret + j ]; + } + buffer_caret += pixel_block_size; + } + } + } + + gdFree( decompression_buffer ); + gdFree( conversion_buffer ); + + } + + /*! \todo Add image type support + * Add support for this image type. + */ + if( tga->imagetype == TGA_TYPE_GREYSCALE ) { + return -1; + } + + /*! \todo Add image type support + * Add support for this image type. + */ + if( tga->imagetype == TGA_TYPE_GREYSCALE_RLE ) { + return -1; + } + + return 0; +} + +/*! \brief Cleans up a TGA structure. + * Dereferences the bitmap referenced in a TGA structure, then the structure itself + * \param tga Pointer to TGA structure + */ +void free_tga(oTga * tga) +{ + if (tga) { + if (tga->ident) { + gdFree(tga->ident); + tga->ident = NULL; + } + if (tga->bitmap) { + gdFree(tga->bitmap); + tga->bitmap = NULL; + } + gdFree(tga); + tga = NULL; + } +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_tga.h b/Build/source/libs/gd/libgd-2.1.1/src/gd_tga.h new file mode 100644 index 00000000000..297f3dc99d6 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_tga.h @@ -0,0 +1,52 @@ +#ifndef __TGA_H +#define __TGA_H 1 + +#include "gd.h" +#include "gdhelpers.h" + +#include "gd_intern.h" + +typedef struct oTga_ { + uint8_t identsize; // size of ID field that follows 18 uint8_t header (0 usually) + uint8_t colormaptype; // type of colour map 0=none, 1=has palette [IGNORED] Adrian requested no support + uint8_t imagetype; // type of image 0=none,1=indexed,2=rgb,3=grey,+8=rle packed + + int colormapstart; // first colour map entry in palette [IGNORED] Adrian requested no support + int colormaplength; // number of colours in palette [IGNORED] Adrian requested no support + uint8_t colormapbits; // number of bits per palette entry 15,16,24,32 [IGNORED] Adrian requested no support + + int xstart; // image x origin + int ystart; // image y origin + int width; // image width in pixels + int height; // image height in pixels + uint8_t bits; // image bits per pixel 8,16,24,32 + uint8_t alphabits; // alpha bits (low 4bits of header 17) + uint8_t fliph; // horizontal or vertical + uint8_t flipv; // flip + char *ident; // identifcation tag string + int *bitmap; // bitmap data + +} oTga; + +#define TGA_TYPE_NO_IMAGE 0 +#define TGA_TYPE_INDEXED 1 +#define TGA_TYPE_RGB 2 +#define TGA_TYPE_GREYSCALE 3 +#define TGA_TYPE_INDEXED_RLE 9 +#define TGA_TYPE_RGB_RLE 10 +#define TGA_TYPE_GREYSCALE_RLE 11 +#define TGA_TYPE_INDEXED_HUFFMAN_DELTA_RLE 32 +#define TGA_TYPE_RGB_HUFFMAN_DELTA_QUADTREE_RLE 33 + +#define TGA_BPP_8 8 +#define TGA_BPP_16 16 +#define TGA_BPP_24 24 +#define TGA_BPP_32 32 + +#define TGA_RLE_FLAG 128 + +int read_header_tga(gdIOCtx *ctx, oTga *tga); +int read_image_tga(gdIOCtx *ctx, oTga *tga); +void free_tga(oTga *tga); + +#endif //__TGA_H diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_tiff.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_tiff.c new file mode 100644 index 00000000000..ec6dd113074 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_tiff.c @@ -0,0 +1,1011 @@ +/* + TIFF - Tagged Image File Format Encapsulation for GD Library + + gd_tiff.c + Copyright (C) Pierre-A. Joye, M. Retallack + + --------------------------------------------------------------------------- + ** + ** Permission to use, copy, modify, and distribute this software and its + ** documentation for any purpose and without fee is hereby granted, provided + ** that the above copyright notice appear in all copies and that both that + ** copyright notice and this permission notice appear in supporting + ** documentation. This software is provided "as is" without express or + ** implied warranty. + ** + --------------------------------------------------------------------------- + Ctx code written by M. Retallack + + Todo: + + If we fail - cleanup + Writer: Use gd error function, overflow check may not be necessary as + we write our own data (check already done) + + Implement 2 color black/white saving using group4 fax compression + Implement function to specify encoding to use when writing tiff data + + ---------------------------------------------------------------------------- + */ +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "gd.h" +#include "gd_errors.h" +#include "gdfonts.h" +#include <stdio.h> +#include <stdlib.h> +#include <limits.h> + +#include "gdhelpers.h" + +#ifdef HAVE_LIBTIFF + +#include "tiff.h" +#include "tiffio.h" + +#define GD_SUCCESS 1 +#define GD_FAILURE 0 + +#define TRUE 1 +#define FALSE 0 + +/* I define those here until the new formats + * are commited. We can then rely on the global + * def + */ +#define GD_PALETTE 1 +#define GD_TRUECOLOR 2 +#define GD_GRAY 3 +#define GD_INDEXED 4 +#define GD_RGB 5 + +#define MIN(a,b) (a < b) ? a : b; +#define MAX(a,b) (a > b) ? a : b; + + +typedef struct tiff_handle { + int size; + int pos; + gdIOCtx *ctx; + int written; +} +tiff_handle; + +/* + Functions for reading, writing and seeking in gdIOCtx + This allows for non-file i/o operations with no + explicit use of libtiff fileio wrapper functions + + Note: because libtiff requires random access, but gdIOCtx + only supports streams, all writes are buffered + into memory and written out on close, also all + reads are done from a memory mapped version of the + tiff (assuming one already exists) +*/ + +tiff_handle * new_tiff_handle(gdIOCtx *g) +{ + tiff_handle * t; + + if (!g) { + gd_error("Cannot create a new tiff handle, missing Ctx argument"); + return NULL; + } + + t = (tiff_handle *) gdMalloc(sizeof(tiff_handle)); + if (!t) { + gd_error("Failed to allocate a new tiff handle"); + return NULL; + } + + t->size = 0; + t->pos = 0; + t->ctx = g; + t->written = 0; + + return t; +} + +/* TIFFReadWriteProc tiff_readproc - Will use gdIOCtx procs to read required + (previously written) TIFF file content */ +static tsize_t tiff_readproc(thandle_t clientdata, tdata_t data, tsize_t size) +{ + tiff_handle *th = (tiff_handle *)clientdata; + gdIOCtx *ctx = th->ctx; + + size = (ctx->getBuf)(ctx, data, size); + + return size; +} + +/* TIFFReadWriteProc tiff_writeproc - Will use gdIOCtx procs to write out + TIFF data */ +static tsize_t tiff_writeproc(thandle_t clientdata, tdata_t data, tsize_t size) +{ + tiff_handle *th = (tiff_handle *)clientdata; + gdIOCtx *ctx = th->ctx; + + size = (ctx->putBuf)(ctx, data, size); + if(size + th->pos>th->size) { + th->size = size + th->pos; + th->pos += size; + } + + return size; +} + +/* TIFFSeekProc tiff_seekproc + * used to move around the partially written TIFF */ +static toff_t tiff_seekproc(thandle_t clientdata, toff_t offset, int from) +{ + tiff_handle *th = (tiff_handle *)clientdata; + gdIOCtx *ctx = th->ctx; + int result; + + switch(from) { + default: + case SEEK_SET: + /* just use offset */ + break; + + case SEEK_END: + /* invert offset, so that it is from start, not end as supplied */ + offset = th->size + offset; + break; + + case SEEK_CUR: + /* add current position to translate it to 'from start', + * not from durrent as supplied + */ + offset += th->pos; + break; + } + + /* now, move pos in both io context and buf */ + if((result = (ctx->seek)(ctx, offset))) { + th->pos = offset; + } + + return result ? offset : (toff_t)-1; +} + +/* TIFFCloseProc tiff_closeproc - used to finally close the TIFF file */ +static int tiff_closeproc(thandle_t clientdata) +{ + (void)clientdata; + /*tiff_handle *th = (tiff_handle *)clientdata; + gdIOCtx *ctx = th->ctx; + + (ctx->gd_free)(ctx);*/ + + return 0; +} + +/* TIFFSizeProc tiff_sizeproc */ +static toff_t tiff_sizeproc(thandle_t clientdata) +{ + tiff_handle *th = (tiff_handle *)clientdata; + return th->size; +} + +/* TIFFMapFileProc tiff_mapproc() */ +static int tiff_mapproc(thandle_t h, tdata_t *d, toff_t *o) +{ + (void)h; + (void)d; + (void)o; + return 0; +} + +/* TIFFUnmapFileProc tiff_unmapproc */ +static void tiff_unmapproc(thandle_t h, tdata_t d, toff_t o) +{ + (void)h; + (void)d; + (void)o; +} + + +/* tiffWriter + * ---------- + * Write the gd image as a tiff file (called by gdImageTiffCtx) + * Parameters are: + * image: gd image structure; + * out: the stream where to write + * bitDepth: depth in bits of each pixel + */ +void tiffWriter(gdImagePtr image, gdIOCtx *out, int bitDepth) +{ + int x, y; + int i; + int r, g, b, a; + TIFF *tiff; + int width, height; + int color; + char *scan; + int samplesPerPixel = 3; + int bitsPerSample; + int transparentColorR = -1; + int transparentColorG = -1; + int transparentColorB = -1; + uint16 extraSamples[1]; + uint16 *colorMapRed = NULL; + uint16 *colorMapGreen = NULL; + uint16 *colorMapBlue = NULL; + + tiff_handle *th; + + th = new_tiff_handle(out); + if (!th) { + return; + } + extraSamples[0] = EXTRASAMPLE_ASSOCALPHA; + + /* read in the width/height of gd image */ + width = gdImageSX(image); + height = gdImageSY(image); + + /* reset clip region to whole image */ + gdImageSetClip(image, 0, 0, width, height); + + /* handle old-style single-colour mapping to 100% transparency */ + if(image->transparent != -1) { + /* set our 100% transparent colour value */ + transparentColorR = gdImageRed(image, image->transparent); + transparentColorG = gdImageGreen(image, image->transparent); + transparentColorB = gdImageBlue(image, image->transparent); + } + + /* Open tiff file writing routines, but use special read/write/seek + * functions so that tiff lib writes correct bits of tiff content to + * correct areas of file opened and modifieable by the gdIOCtx functions + */ + tiff = TIFFClientOpen("", "w", th, tiff_readproc, + tiff_writeproc, + tiff_seekproc, + tiff_closeproc, + tiff_sizeproc, + tiff_mapproc, + tiff_unmapproc); + + TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, width); + TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, height); + TIFFSetField(tiff, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE); + TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG); + TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, + (bitDepth == 24) ? PHOTOMETRIC_RGB : PHOTOMETRIC_PALETTE); + + bitsPerSample = (bitDepth == 24 || bitDepth == 8) ? 8 : 1; + TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, bitsPerSample); + + /* build the color map for 8 bit images */ + if(bitDepth != 24) { + colorMapRed = (uint16 *) gdMalloc(3 * (1 << bitsPerSample)); + if (!colorMapRed) { + return; + } + colorMapGreen = (uint16 *) gdMalloc(3 * (1 << bitsPerSample)); + if (!colorMapGreen) { + gdFree(colorMapRed); + return; + } + colorMapBlue = (uint16 *) gdMalloc(3 * (1 << bitsPerSample)); + if (!colorMapBlue) { + gdFree(colorMapRed); + gdFree(colorMapGreen); + return; + } + + for(i = 0; i < image->colorsTotal; i++) { + colorMapRed[i] = gdImageRed(image,i) + (gdImageRed(image,i) * 256); + colorMapGreen[i] = gdImageGreen(image,i)+(gdImageGreen(image,i)*256); + colorMapBlue[i] = gdImageBlue(image,i) + (gdImageBlue(image,i)*256); + } + + TIFFSetField(tiff, TIFFTAG_COLORMAP, colorMapRed, colorMapGreen, + colorMapBlue); + samplesPerPixel = 1; + } + + /* here, we check if the 'save alpha' flag is set on the source gd image */ + if ((bitDepth == 24) && + (image->saveAlphaFlag || image->transparent != -1)) { + /* so, we need to store the alpha values too! + * Also, tell TIFF what the extra sample means (associated alpha) */ + samplesPerPixel = 4; + TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, samplesPerPixel); + TIFFSetField(tiff, TIFFTAG_EXTRASAMPLES, 1, extraSamples); + } else { + TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, samplesPerPixel); + } + + TIFFSetField(tiff, TIFFTAG_ROWSPERSTRIP, 1); + + if(overflow2(width, samplesPerPixel)) { + return; + } + + if(!(scan = (char *)gdMalloc(width * samplesPerPixel))) { + return; + } + + /* loop through y-coords, and x-coords */ + for(y = 0; y < height; y++) { + for(x = 0; x < width; x++) { + /* generate scan line for writing to tiff */ + color = gdImageGetPixel(image, x, y); + + a = (127 - gdImageAlpha(image, color)) * 2; + a = (a == 0xfe) ? 0xff : a & 0xff; + b = gdImageBlue(image, color); + g = gdImageGreen(image, color); + r = gdImageRed(image, color); + + /* if this pixel has the same RGB as the transparent colour, + * then set alpha fully transparent */ + if (transparentColorR == r && + transparentColorG == g && + transparentColorB == b) { + a = 0x00; + } + + if(bitDepth != 24) { + /* write out 1 or 8 bit value in 1 byte + * (currently treats 1bit as 8bit) */ + scan[(x * samplesPerPixel) + 0] = color; + } else { + /* write out 24 bit value in 3 (or 4 if transparent) bytes */ + if(image->saveAlphaFlag || image->transparent != -1) { + scan[(x * samplesPerPixel) + 3] = a; + } + + scan[(x * samplesPerPixel) + 2] = b; + scan[(x * samplesPerPixel) + 1] = g; + scan[(x * samplesPerPixel) + 0] = r; + } + } + + /* Write the scan line to the tiff */ + if(TIFFWriteEncodedStrip(tiff, y, scan, width * samplesPerPixel) == -1) { + /* error handler here */ + gd_error("Could not create TIFF\n"); + return; + } + } + + /* now cloase and free up resources */ + TIFFClose(tiff); + gdFree(scan); + gdFree(th); + + if(bitDepth != 24) { + gdFree(colorMapRed); + gdFree(colorMapGreen); + gdFree(colorMapBlue); + } +} + +/* + gdImageTiffCtx + -------------- + Write the gd image as a tiff file + Parameters are: + image: gd image structure; + out: the stream where to write + */ +BGD_DECLARE(void) gdImageTiffCtx(gdImagePtr image, gdIOCtx *out) +{ + int clipx1P, clipy1P, clipx2P, clipy2P; + int bitDepth = 24; + + /* First, switch off clipping, or we'll not get all the image! */ + gdImageGetClip(image, &clipx1P, &clipy1P, &clipx2P, &clipy2P); + + /* use the appropriate routine depending on the bit depth of the image */ + if(image->trueColor) { + bitDepth = 24; + } else if(image->colorsTotal == 2) { + bitDepth = 1; + } else { + bitDepth = 8; + } + + tiffWriter(image, out, bitDepth); + + /* reset clipping area to the gd image's original values */ + gdImageSetClip(image, clipx1P, clipy1P, clipx2P, clipy2P); +} + +/* Check if we are really in 8bit mode */ +static int checkColorMap(n, r, g, b) +int n; +uint16 *r, *g, *b; +{ + while (n-- > 0) + if (*r++ >= 256 || *g++ >= 256 || *b++ >= 256) + return (16); + return (8); +} + + +/* Read and convert a TIFF colormap */ +static int readTiffColorMap(gdImagePtr im, TIFF *tif, char is_bw, int photometric) +{ + uint16 *redcmap, *greencmap, *bluecmap; + uint16 bps; + int i; + + if (is_bw) { + if (photometric == PHOTOMETRIC_MINISWHITE) { + gdImageColorAllocate(im, 255,255,255); + gdImageColorAllocate(im, 0, 0, 0); + } else { + gdImageColorAllocate(im, 0, 0, 0); + gdImageColorAllocate(im, 255,255,255); + } + } else { + uint16 min_sample_val, max_sample_val; + + if (!TIFFGetField(tif, TIFFTAG_MINSAMPLEVALUE, &min_sample_val)) { + min_sample_val = 0; + } + if (!TIFFGetField(tif, TIFFTAG_MAXSAMPLEVALUE, &max_sample_val)) { + max_sample_val = 255; + } + + if (photometric == PHOTOMETRIC_MINISBLACK || photometric == PHOTOMETRIC_MINISWHITE) { + /* TODO: use TIFFTAG_MINSAMPLEVALUE and TIFFTAG_MAXSAMPLEVALUE */ + /* Gray level palette */ + for (i=min_sample_val; i <= max_sample_val; i++) { + gdImageColorAllocate(im, i,i,i); + } + return GD_SUCCESS; + + } else if (!TIFFGetField(tif, TIFFTAG_COLORMAP, &redcmap, &greencmap, &bluecmap)) { + gd_error("Cannot read the color map"); + return GD_FAILURE; + } + + TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &bps); + +#define CVT(x) (((x) * 255) / ((1L<<16)-1)) + if (checkColorMap(1<<bps, redcmap, greencmap, bluecmap) == 16) { + for (i = (1<<bps)-1; i > 0; i--) { + redcmap[i] = CVT(redcmap[i]); + greencmap[i] = CVT(greencmap[i]); + bluecmap[i] = CVT(bluecmap[i]); + } + } + for (i = 0; i < 256; i++) { + gdImageColorAllocate(im, redcmap[i], greencmap[i], bluecmap[i]); + } +#undef CVT + } + return GD_SUCCESS; +} + +static void readTiffBw (const unsigned char *src, + gdImagePtr im, + uint16 photometric, + int startx, + int starty, + int width, + int height, + char has_alpha, + int extra, + int align) +{ + int x = startx, y = starty; + + (void)has_alpha; + (void)extra; + (void)align; + + for (y = starty; y < starty + height; y++) { + for (x = startx; x < startx + width; x++) { + register unsigned char curr = *src++; + register unsigned char mask; + + if (photometric == PHOTOMETRIC_MINISWHITE) { + curr = ~curr; + } + for (mask = 0x80; mask != 0 && x < startx + width; mask >>= 1) { + gdImageSetPixel(im, x, y, ((curr & mask) != 0)?0:1); + } + } + } +} + +static void readTiff8bit (const unsigned char *src, + gdImagePtr im, + uint16 photometric, + int startx, + int starty, + int width, + int height, + char has_alpha, + int extra, + int align) +{ + int red, green, blue, alpha; + int x, y; + + (void)extra; + (void)align; + + switch (photometric) { + case PHOTOMETRIC_PALETTE: + /* Palette has no alpha (see TIFF specs for more details */ + for (y = starty; y < starty + height; y++) { + for (x = startx; x < startx + width; x++) { + gdImageSetPixel(im, x, y,*(src++)); + } + } + break; + + case PHOTOMETRIC_RGB: + if (has_alpha) { + gdImageAlphaBlending(im, 0); + gdImageSaveAlpha(im, 1); + + for (y = starty; y < starty + height; y++) { + for (x = startx; x < startx + width; x++) { + red = *src++; + green = *src++; + blue = *src++; + alpha = *src++; + red = MIN (red, alpha); + blue = MIN (blue, alpha); + green = MIN (green, alpha); + + if (alpha) { + gdImageSetPixel(im, x, y, gdTrueColorAlpha(red * 255 / alpha, green * 255 / alpha, blue * 255 /alpha, gdAlphaMax - (alpha >> 1))); + } else { + gdImageSetPixel(im, x, y, gdTrueColorAlpha(red, green, blue, gdAlphaMax - (alpha >> 1))); + } + } + } + + } else { + for (y = 0; y < height; y++) { + for (x = 0; x < width; x++) { + register unsigned char r = *src++; + register unsigned char g = *src++; + register unsigned char b = *src++; + + gdImageSetPixel(im, x, y, gdTrueColor(r, g, b)); + } + } + } + break; + + case PHOTOMETRIC_MINISWHITE: + if (has_alpha) { + /* We don't process the extra yet */ + } else { + for (y = starty; y < starty + height; y++) { + for (x = startx; x < startx + width; x++) { + gdImageSetPixel(im, x, y, ~(*src++)); + } + } + } + break; + + case PHOTOMETRIC_MINISBLACK: + if (has_alpha) { + /* We don't process the extra yet */ + } else { + for (y = starty; y < height; y++) { + for (x = 0; x < width; x++) { + gdImageSetPixel(im, x, y, *src++); + } + } + } + break; + } +} + +static int createFromTiffTiles(TIFF *tif, gdImagePtr im, uint16 bps, uint16 photometric, + char has_alpha, char is_bw, int extra) +{ + uint16 planar; + int im_width, im_height; + int tile_width, tile_height; + int x, y, height, width; + unsigned char *buffer; + + if (!TIFFGetField (tif, TIFFTAG_PLANARCONFIG, &planar)) { + planar = PLANARCONFIG_CONTIG; + } + TIFFGetField (tif, TIFFTAG_IMAGEWIDTH, &im_width); + TIFFGetField (tif, TIFFTAG_IMAGELENGTH, &im_height); + TIFFGetField (tif, TIFFTAG_TILEWIDTH, &tile_width); + TIFFGetField (tif, TIFFTAG_TILELENGTH, &tile_height); + + buffer = (unsigned char *) gdMalloc (TIFFTileSize (tif)); + if (!buffer) { + return FALSE; + } + + for (y = 0; y < im_height; y += tile_height) { + for (x = 0; x < im_width; x += tile_width) { + TIFFReadTile(tif, buffer, x, y, 0, 0); + width = MIN(im_width - x, tile_width); + height = MIN(im_height - y, tile_height); + if (bps == 16) { + } else if (bps == 8) { + readTiff8bit(buffer, im, photometric, x, y, width, height, has_alpha, extra, 0); + } else if (is_bw) { + readTiffBw(buffer, im, photometric, x, y, width, height, has_alpha, extra, 0); + } else { + /* TODO: implement some default reader or detect this case earlier use force_rgb */ + } + } + } + return TRUE; +} + +static int createFromTiffLines(TIFF *tif, gdImagePtr im, uint16 bps, uint16 photometric, + char has_alpha, char is_bw, int extra) +{ + uint16 planar; + uint32 im_height, im_width, y; + + unsigned char *buffer; + + if (!TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &planar)) { + planar = PLANARCONFIG_CONTIG; + } + + if (!TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &im_height)) { + gd_error("Can't fetch TIFF height\n"); + return FALSE; + } + + if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &im_width)) { + gd_error("Can't fetch TIFF width \n"); + return FALSE; + } + + buffer = (unsigned char *)gdMalloc(im_width * 4); + if (!buffer) { + return GD_FAILURE; + } + if (planar == PLANARCONFIG_CONTIG) { + switch (bps) { + case 16: + /* TODO + * or simply use force_rgba + */ + break; + + case 8: + for (y = 0; y < im_height; y++ ) { + if (!TIFFReadScanline (tif, buffer, y, 0)) { + gd_error("Error while reading scanline %i", y); + break; + } + /* reading one line at a time */ + readTiff8bit(buffer, im, photometric, 0, y, im_width, 1, has_alpha, extra, 0); + } + break; + + default: + if (is_bw) { + for (y = 0; y < im_height; y++ ) { + if (!TIFFReadScanline (tif, buffer, y, 0)) { + gd_error("Error while reading scanline %i", y); + break; + } + /* reading one line at a time */ + readTiffBw(buffer, im, photometric, 0, y, im_width, 1, has_alpha, extra, 0); + } + } else { + /* TODO: implement some default reader or detect this case earlier > force_rgb */ + } + break; + } + } else { + /* TODO: implement a reader for separate panes. We detect this case earlier for now and use force_rgb */ + } + + gdFree(buffer); + return GD_SUCCESS; +} + +static int createFromTiffRgba(TIFF * tif, gdImagePtr im) +{ + int a; + int x, y; + int alphaBlendingFlag = 0; + int color; + int width = im->sx; + int height = im->sy; + uint32 *buffer; + uint32 rgba; + + /* switch off colour merging on target gd image just while we write out + * content - we want to preserve the alpha data until the user chooses + * what to do with the image */ + alphaBlendingFlag = im->alphaBlendingFlag; + gdImageAlphaBlending(im, 0); + + buffer = (uint32 *) gdCalloc(sizeof(uint32), width * height); + if (!buffer) { + return GD_FAILURE; + } + + TIFFReadRGBAImage(tif, width, height, buffer, 0); + + for(y = 0; y < height; y++) { + for(x = 0; x < width; x++) { + /* if it doesn't already exist, allocate a new colour, + * else use existing one */ + rgba = buffer[(y * width + x)]; + a = (0xff - TIFFGetA(rgba)) / 2; + color = gdTrueColorAlpha(TIFFGetR(rgba), TIFFGetG(rgba), TIFFGetB(rgba), a); + + /* set pixel colour to this colour */ + gdImageSetPixel(im, x, height - y - 1, color); + } + } + + gdFree(buffer); + + /* now reset colour merge for alpha blending routines */ + gdImageAlphaBlending(im, alphaBlendingFlag); + return GD_SUCCESS; +} + +/* gdImageCreateFromTiffCtx +** ------------------------ +** Create a gdImage from a TIFF file input from an gdIOCtx + */ +BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffCtx(gdIOCtx *infile) +{ + TIFF *tif; + tiff_handle *th; + + uint16 bps, spp, photometric; + uint16 orientation; + int width, height; + uint16 extra, *extra_types; + uint16 planar; + char has_alpha, is_bw, is_gray; + char force_rgba = FALSE; + char save_transparent; + int image_type; + int ret; + + gdImagePtr im = NULL; + + th = new_tiff_handle(infile); + if (!th) { + return NULL; + } + + tif = TIFFClientOpen("", "rb", th, tiff_readproc, + tiff_writeproc, + tiff_seekproc, + tiff_closeproc, + tiff_sizeproc, + tiff_mapproc, + tiff_unmapproc); + + if (!tif) { + gd_error("Cannot open TIFF image"); + return NULL; + } + + if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width)) { + gd_error("TIFF error, Cannot read image width"); + goto error; + } + + if (!TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height)) { + gd_error("TIFF error, Cannot read image width"); + goto error; + } + + TIFFGetFieldDefaulted (tif, TIFFTAG_BITSPERSAMPLE, &bps); + + /* Unsupported bps, force to RGBA */ + if (bps > 8 && bps != 16) { + force_rgba = TRUE; + } + + TIFFGetFieldDefaulted (tif, TIFFTAG_SAMPLESPERPIXEL, &spp); + + if (!TIFFGetField (tif, TIFFTAG_EXTRASAMPLES, &extra, &extra_types)) { + extra = 0; + } + + if (!TIFFGetField (tif, TIFFTAG_PHOTOMETRIC, &photometric)) { + uint16 compression; + if (TIFFGetField(tif, TIFFTAG_COMPRESSION, &compression) && + (compression == COMPRESSION_CCITTFAX3 || + compression == COMPRESSION_CCITTFAX4 || + compression == COMPRESSION_CCITTRLE || + compression == COMPRESSION_CCITTRLEW)) { + gd_error("Could not get photometric. " + "Image is CCITT compressed, assuming min-is-white"); + photometric = PHOTOMETRIC_MINISWHITE; + } else { + gd_error("Could not get photometric. " + "Assuming min-is-black"); + + photometric = PHOTOMETRIC_MINISBLACK; + } + } + save_transparent = FALSE; + + /* test if the extrasample represents an associated alpha channel... */ + if (extra > 0 && (extra_types[0] == EXTRASAMPLE_ASSOCALPHA)) { + has_alpha = TRUE; + save_transparent = FALSE; + --extra; + } else if (extra > 0 && (extra_types[0] == EXTRASAMPLE_UNASSALPHA)) { + has_alpha = TRUE; + save_transparent = TRUE; + --extra; + } else if (extra > 0 && (extra_types[0] == EXTRASAMPLE_UNSPECIFIED)) { + /* assuming unassociated alpha if unspecified */ + gd_error("alpha channel type not defined, assuming alpha is not premultiplied"); + has_alpha = TRUE; + save_transparent = TRUE; + --extra; + } else { + has_alpha = FALSE; + } + + if (photometric == PHOTOMETRIC_RGB && spp > 3 + extra) { + has_alpha = TRUE; + extra = spp - 4; + } else if (photometric != PHOTOMETRIC_RGB && spp > 1 + extra) { + has_alpha = TRUE; + extra = spp - 2; + } + + is_bw = FALSE; + is_gray = FALSE; + + switch (photometric) { + case PHOTOMETRIC_MINISBLACK: + case PHOTOMETRIC_MINISWHITE: + if (!has_alpha && bps == 1 && spp == 1) { + image_type = GD_INDEXED; + is_bw = TRUE; + } else { + image_type = GD_GRAY; + } + break; + + case PHOTOMETRIC_RGB: + image_type = GD_RGB; + break; + + case PHOTOMETRIC_PALETTE: + image_type = GD_INDEXED; + break; + + default: + force_rgba = TRUE; + break; + } + + if (!TIFFGetField (tif, TIFFTAG_PLANARCONFIG, &planar)) { + planar = PLANARCONFIG_CONTIG; + } + + /* Force rgba if image plans are not contiguous */ + if (force_rgba || planar != PLANARCONFIG_CONTIG) { + image_type = GD_RGB; + } + + if (!force_rgba && + (image_type == GD_PALETTE || image_type == GD_INDEXED || image_type == GD_GRAY)) { + im = gdImageCreate(width, height); + if (!im) goto error; + readTiffColorMap(im, tif, is_bw, photometric); + } else { + im = gdImageCreateTrueColor(width, height); + if (!im) goto error; + } + +#ifdef DEBUG + printf("force rgba: %i\n", force_rgba); + printf("has_alpha: %i\n", has_alpha); + printf("save trans: %i\n", save_transparent); + printf("is_bw: %i\n", is_bw); + printf("is_gray: %i\n", is_gray); + printf("type: %i\n", image_type); +#else + (void)is_gray; + (void)save_transparent; +#endif + + if (force_rgba) { + ret = createFromTiffRgba(tif, im); + } else if (TIFFIsTiled(tif)) { + ret = createFromTiffTiles(tif, im, bps, photometric, has_alpha, is_bw, extra); + } else { + ret = createFromTiffLines(tif, im, bps, photometric, has_alpha, is_bw, extra); + } + + if (!ret) { + gdImageDestroy(im); + im = NULL; + goto error; + } + + if (TIFFGetField (tif, TIFFTAG_ORIENTATION, &orientation)) { + switch (orientation) { + case ORIENTATION_TOPLEFT: + case ORIENTATION_TOPRIGHT: + case ORIENTATION_BOTRIGHT: + case ORIENTATION_BOTLEFT: + break; + + default: + gd_error("Orientation %d not handled yet!", orientation); + break; + } + } +error: + TIFFClose(tif); + return im; +} + +/* gdImageCreateFromTIFF +** --------------------- + */ +BGD_DECLARE(gdImagePtr) gdImageCreateFromTiff(FILE *inFile) +{ + gdImagePtr im; + gdIOCtx *in = gdNewFileCtx(inFile); + if (in == NULL) return NULL; + im = gdImageCreateFromTiffCtx(in); + in->gd_free(in); + return im; +} + +BGD_DECLARE(gdImagePtr) gdImageCreateFromTiffPtr(int size, void *data) +{ + gdImagePtr im; + gdIOCtx *in = gdNewDynamicCtxEx (size, data, 0); + if (in == NULL) return NULL; + im = gdImageCreateFromTiffCtx(in); + in->gd_free(in); + return im; +} + +/* gdImageTIFF +** ----------- + */ +BGD_DECLARE(void) gdImageTiff(gdImagePtr im, FILE *outFile) +{ + gdIOCtx *out = gdNewFileCtx(outFile); + if (out == NULL) return; + gdImageTiffCtx(im, out); /* what's an fg again? */ + out->gd_free(out); +} + +/* gdImageTIFFPtr +** -------------- + */ +BGD_DECLARE(void *) gdImageTiffPtr(gdImagePtr im, int *size) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx (2048, NULL); + if (out == NULL) return NULL; + gdImageTiffCtx(im, out); /* what's an fg again? */ + rv = gdDPExtractData(out, size); + out->gd_free(out); + return rv; +} + +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_topal.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_topal.c new file mode 100644 index 00000000000..28b6503d063 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_topal.c @@ -0,0 +1,1725 @@ +/* TODO: oim and nim in the lower level functions; + correct use of stub (sigh). */ + +/* 2.0.12: a new adaptation from the same original, this time + by Barend Gehrels. My attempt to incorporate alpha channel + into the result worked poorly and degraded the quality of + palette conversion even when the source contained no + alpha channel data. This version does not attempt to produce + an output file with transparency in some of the palette + indexes, which, in practice, doesn't look so hot anyway. TBB */ + +/* + * gd_topal, adapted from jquant2.c + * + * Copyright (C) 1991-1996, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains 2-pass color quantization (color mapping) routines. + * These routines provide selection of a custom color map for an image, + * followed by mapping of the image to that color map, with optional + * Floyd-Steinberg dithering. + * It is also possible to use just the second pass to map to an arbitrary + * externally-given color map. + * + * Note: ordered dithering is not supported, since there isn't any fast + * way to compute intercolor distances; it's unclear that ordered dither's + * fundamental assumptions even hold with an irregularly spaced color map. + */ + + +/* + * THOMAS BOUTELL & BAREND GEHRELS, february 2003 + * adapted the code to work within gd rather than within libjpeg. + * If it is not working, it's not Thomas G. Lane's fault. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <string.h> +#include "gd.h" +#include "gdhelpers.h" + +#ifdef HAVE_LIBIMAGEQUANT_H +#include <libimagequant.h> /* if this fails then set -DENABLE_LIQ=NO in cmake or make static libimagequant.a in libimagequant/ */ +#endif + +/* (Re)define some defines known by libjpeg */ +#define QUANT_2PASS_SUPPORTED + +#define RGB_RED 0 +#define RGB_GREEN 1 +#define RGB_BLUE 2 + +#define JSAMPLE unsigned char +#define MAXJSAMPLE (gdMaxColors-1) +#define BITS_IN_JSAMPLE 8 + +#define JSAMPROW int* +#define JDIMENSION int + +#define METHODDEF(type) static type +#define LOCAL(type) static type + + +/* We assume that right shift corresponds to signed division by 2 with + * rounding towards minus infinity. This is correct for typical "arithmetic + * shift" instructions that shift in copies of the sign bit. But some + * C compilers implement >> with an unsigned shift. For these machines you + * must define RIGHT_SHIFT_IS_UNSIGNED. + * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity. + * It is only applied with constant shift counts. SHIFT_TEMPS must be + * included in the variables of any routine using RIGHT_SHIFT. + */ + +#ifdef RIGHT_SHIFT_IS_UNSIGNED +#define SHIFT_TEMPS INT32 shift_temp; +#define RIGHT_SHIFT(x,shft) \ + ((shift_temp = (x)) < 0 ? \ + (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \ + (shift_temp >> (shft))) +#else +#define SHIFT_TEMPS +#define RIGHT_SHIFT(x,shft) ((x) >> (shft)) +#endif + + +#define range_limit(x) { if(x<0) x=0; if (x>255) x=255; } + + +#ifndef INT16 +#define INT16 short +#endif + +#ifndef UINT16 +#define UINT16 unsigned short +#endif + +#ifndef INT32 +#define INT32 int +#endif + +#ifndef FAR +#define FAR +#endif + + + +#ifndef boolean +#define boolean int +#endif + +#ifndef TRUE +#define TRUE 1 +#endif + +#ifndef FALSE +#define FALSE 0 +#endif + + +#define input_buf (oim->tpixels) +#define output_buf (nim->pixels) + + +#ifdef QUANT_2PASS_SUPPORTED + + +/* + * This module implements the well-known Heckbert paradigm for color + * quantization. Most of the ideas used here can be traced back to + * Heckbert's seminal paper + * Heckbert, Paul. "Color Image Quantization for Frame Buffer Display", + * Proc. SIGGRAPH '82, Computer Graphics v.16 #3 (July 1982), pp 297-304. + * + * In the first pass over the image, we accumulate a histogram showing the + * usage count of each possible color. To keep the histogram to a reasonable + * size, we reduce the precision of the input; typical practice is to retain + * 5 or 6 bits per color, so that 8 or 4 different input values are counted + * in the same histogram cell. + * + * Next, the color-selection step begins with a box representing the whole + * color space, and repeatedly splits the "largest" remaining box until we + * have as many boxes as desired colors. Then the mean color in each + * remaining box becomes one of the possible output colors. + * + * The second pass over the image maps each input pixel to the closest output + * color (optionally after applying a Floyd-Steinberg dithering correction). + * This mapping is logically trivial, but making it go fast enough requires + * considerable care. + * + * Heckbert-style quantizers vary a good deal in their policies for choosing + * the "largest" box and deciding where to cut it. The particular policies + * used here have proved out well in experimental comparisons, but better ones + * may yet be found. + * + * In earlier versions of the IJG code, this module quantized in YCbCr color + * space, processing the raw upsampled data without a color conversion step. + * This allowed the color conversion math to be done only once per colormap + * entry, not once per pixel. However, that optimization precluded other + * useful optimizations (such as merging color conversion with upsampling) + * and it also interfered with desired capabilities such as quantizing to an + * externally-supplied colormap. We have therefore abandoned that approach. + * The present code works in the post-conversion color space, typically RGB. + * + * To improve the visual quality of the results, we actually work in scaled + * RGB space, giving G distances more weight than R, and R in turn more than + * B. To do everything in integer math, we must use integer scale factors. + * The 2/3/1 scale factors used here correspond loosely to the relative + * weights of the colors in the NTSC grayscale equation. + * If you want to use this code to quantize a non-RGB color space, you'll + * probably need to change these scale factors. + */ + +#define R_SCALE 2 /* scale R distances by this much */ +#define G_SCALE 3 /* scale G distances by this much */ +#define B_SCALE 1 /* and B by this much */ + +/* Relabel R/G/B as components 0/1/2, respecting the RGB ordering defined + * in jmorecfg.h. As the code stands, it will do the right thing for R,G,B + * and B,G,R orders. If you define some other weird order in jmorecfg.h, + * you'll get compile errors until you extend this logic. In that case + * you'll probably want to tweak the histogram sizes too. + */ + +#if RGB_RED == 0 +#define C0_SCALE R_SCALE +#endif +#if RGB_BLUE == 0 +#define C0_SCALE B_SCALE +#endif +#if RGB_GREEN == 1 +#define C1_SCALE G_SCALE +#endif +#if RGB_RED == 2 +#define C2_SCALE R_SCALE +#endif +#if RGB_BLUE == 2 +#define C2_SCALE B_SCALE +#endif + + +/* + * First we have the histogram data structure and routines for creating it. + * + * The number of bits of precision can be adjusted by changing these symbols. + * We recommend keeping 6 bits for G and 5 each for R and B. + * If you have plenty of memory and cycles, 6 bits all around gives marginally + * better results; if you are short of memory, 5 bits all around will save + * some space but degrade the results. + * To maintain a fully accurate histogram, we'd need to allocate a "long" + * (preferably unsigned long) for each cell. In practice this is overkill; + * we can get by with 16 bits per cell. Few of the cell counts will overflow, + * and clamping those that do overflow to the maximum value will give close- + * enough results. This reduces the recommended histogram size from 256Kb + * to 128Kb, which is a useful savings on PC-class machines. + * (In the second pass the histogram space is re-used for pixel mapping data; + * in that capacity, each cell must be able to store zero to the number of + * desired colors. 16 bits/cell is plenty for that too.) + * Since the JPEG code is intended to run in small memory model on 80x86 + * machines, we can't just allocate the histogram in one chunk. Instead + * of a true 3-D array, we use a row of pointers to 2-D arrays. Each + * pointer corresponds to a C0 value (typically 2^5 = 32 pointers) and + * each 2-D array has 2^6*2^5 = 2048 or 2^6*2^6 = 4096 entries. Note that + * on 80x86 machines, the pointer row is in near memory but the actual + * arrays are in far memory (same arrangement as we use for image arrays). + */ + +#define MAXNUMCOLORS (MAXJSAMPLE+1) /* maximum size of colormap */ + +/* These will do the right thing for either R,G,B or B,G,R color order, + * but you may not like the results for other color orders. + */ +#define HIST_C0_BITS 5 /* bits of precision in R/B histogram */ +#define HIST_C1_BITS 6 /* bits of precision in G histogram */ +#define HIST_C2_BITS 5 /* bits of precision in B/R histogram */ + +/* Number of elements along histogram axes. */ +#define HIST_C0_ELEMS (1<<HIST_C0_BITS) +#define HIST_C1_ELEMS (1<<HIST_C1_BITS) +#define HIST_C2_ELEMS (1<<HIST_C2_BITS) + +/* These are the amounts to shift an input value to get a histogram index. */ +#define C0_SHIFT (BITS_IN_JSAMPLE-HIST_C0_BITS) +#define C1_SHIFT (BITS_IN_JSAMPLE-HIST_C1_BITS) +#define C2_SHIFT (BITS_IN_JSAMPLE-HIST_C2_BITS) + + +typedef UINT16 histcell; /* histogram cell; prefer an unsigned type */ + +typedef histcell FAR *histptr; /* for pointers to histogram cells */ + +typedef histcell hist1d[HIST_C2_ELEMS]; /* typedefs for the array */ +typedef hist1d FAR *hist2d; /* type for the 2nd-level pointers */ +typedef hist2d *hist3d; /* type for top-level pointer */ + + +/* Declarations for Floyd-Steinberg dithering. + * + * Errors are accumulated into the array fserrors[], at a resolution of + * 1/16th of a pixel count. The error at a given pixel is propagated + * to its not-yet-processed neighbors using the standard F-S fractions, + * ... (here) 7/16 + * 3/16 5/16 1/16 + * We work left-to-right on even rows, right-to-left on odd rows. + * + * We can get away with a single array (holding one row's worth of errors) + * by using it to store the current row's errors at pixel columns not yet + * processed, but the next row's errors at columns already processed. We + * need only a few extra variables to hold the errors immediately around the + * current column. (If we are lucky, those variables are in registers, but + * even if not, they're probably cheaper to access than array elements are.) + * + * The fserrors[] array has (#columns + 2) entries; the extra entry at + * each end saves us from special-casing the first and last pixels. + * Each entry is three values long, one value for each color component. + * + * Note: on a wide image, we might not have enough room in a PC's near data + * segment to hold the error array; so it is allocated with alloc_large. + */ + +#if BITS_IN_JSAMPLE == 8 +typedef INT16 FSERROR; /* 16 bits should be enough */ +typedef int LOCFSERROR; /* use 'int' for calculation temps */ +#else +typedef INT32 FSERROR; /* may need more than 16 bits */ +typedef INT32 LOCFSERROR; /* be sure calculation temps are big enough */ +#endif + +typedef FSERROR FAR *FSERRPTR; /* pointer to error array (in FAR storage!) */ + + +/* Private subobject */ + +typedef struct { + /* Variables for accumulating image statistics */ + hist3d histogram; /* pointer to the histogram */ + + + /* Variables for Floyd-Steinberg dithering */ + FSERRPTR fserrors; /* accumulated errors */ + + boolean on_odd_row; /* flag to remember which row we are on */ + int *error_limiter; /* table for clamping the applied error */ + int *error_limiter_storage; /* gdMalloc'd storage for the above */ +} +my_cquantizer; + +typedef my_cquantizer *my_cquantize_ptr; + + +/* + * Prescan some rows of pixels. + * In this module the prescan simply updates the histogram, which has been + * initialized to zeroes by start_pass. + * An output_buf parameter is required by the method signature, but no data + * is actually output (in fact the buffer controller is probably passing a + * NULL pointer). + */ + +METHODDEF (void) +prescan_quantize (gdImagePtr oim, gdImagePtr nim, my_cquantize_ptr cquantize) +{ + register JSAMPROW ptr; + register histptr histp; + register hist3d histogram = cquantize->histogram; + int row; + JDIMENSION col; + int width = oim->sx; + int num_rows = oim->sy; + + (void)nim; + + for (row = 0; row < num_rows; row++) { + ptr = input_buf[row]; + for (col = width; col > 0; col--) { + int r = gdTrueColorGetRed (*ptr) >> C0_SHIFT; + int g = gdTrueColorGetGreen (*ptr) >> C1_SHIFT; + int b = gdTrueColorGetBlue (*ptr) >> C2_SHIFT; + /* 2.0.12: Steven Brown: support a single totally transparent + color in the original. */ + if ((oim->transparent >= 0) && (*ptr == oim->transparent)) { + ptr++; + continue; + } + /* get pixel value and index into the histogram */ + histp = &histogram[r][g][b]; + /* increment, check for overflow and undo increment if so. */ + if (++(*histp) == 0) + (*histp)--; + ptr++; + } + } +} + + +/* + * Next we have the really interesting routines: selection of a colormap + * given the completed histogram. + * These routines work with a list of "boxes", each representing a rectangular + * subset of the input color space (to histogram precision). + */ + +typedef struct { + /* The bounds of the box (inclusive); expressed as histogram indexes */ + int c0min, c0max; + int c1min, c1max; + int c2min, c2max; + /* The volume (actually 2-norm) of the box */ + INT32 volume; + /* The number of nonzero histogram cells within this box */ + long colorcount; +} +box; + +typedef box *boxptr; + + +LOCAL (boxptr) find_biggest_color_pop (boxptr boxlist, int numboxes) +/* Find the splittable box with the largest color population */ +/* Returns NULL if no splittable boxes remain */ +{ + register boxptr boxp; + register int i; + register long maxc = 0; + boxptr which = NULL; + + for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) { + if (boxp->colorcount > maxc && boxp->volume > 0) { + which = boxp; + maxc = boxp->colorcount; + } + } + return which; +} + + +LOCAL (boxptr) find_biggest_volume (boxptr boxlist, int numboxes) +/* Find the splittable box with the largest (scaled) volume */ +/* Returns NULL if no splittable boxes remain */ +{ + register boxptr boxp; + register int i; + register INT32 maxv = 0; + boxptr which = NULL; + + for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) { + if (boxp->volume > maxv) { + which = boxp; + maxv = boxp->volume; + } + } + return which; +} + + +LOCAL (void) +update_box (gdImagePtr oim, gdImagePtr nim, my_cquantize_ptr cquantize, boxptr boxp) +{ + hist3d histogram = cquantize->histogram; + histptr histp; + int c0, c1, c2; + int c0min, c0max, c1min, c1max, c2min, c2max; + INT32 dist0, dist1, dist2; + long ccount; + (void)oim; + (void)nim; + + c0min = boxp->c0min; + c0max = boxp->c0max; + c1min = boxp->c1min; + c1max = boxp->c1max; + c2min = boxp->c2min; + c2max = boxp->c2max; + + if (c0max > c0min) + for (c0 = c0min; c0 <= c0max; c0++) + for (c1 = c1min; c1 <= c1max; c1++) { + histp = &histogram[c0][c1][c2min]; + for (c2 = c2min; c2 <= c2max; c2++) + if (*histp++ != 0) { + boxp->c0min = c0min = c0; + goto have_c0min; + } + } +have_c0min: + if (c0max > c0min) + for (c0 = c0max; c0 >= c0min; c0--) + for (c1 = c1min; c1 <= c1max; c1++) { + histp = &histogram[c0][c1][c2min]; + for (c2 = c2min; c2 <= c2max; c2++) + if (*histp++ != 0) { + boxp->c0max = c0max = c0; + goto have_c0max; + } + } +have_c0max: + if (c1max > c1min) + for (c1 = c1min; c1 <= c1max; c1++) + for (c0 = c0min; c0 <= c0max; c0++) { + histp = &histogram[c0][c1][c2min]; + for (c2 = c2min; c2 <= c2max; c2++) + if (*histp++ != 0) { + boxp->c1min = c1min = c1; + goto have_c1min; + } + } +have_c1min: + if (c1max > c1min) + for (c1 = c1max; c1 >= c1min; c1--) + for (c0 = c0min; c0 <= c0max; c0++) { + histp = &histogram[c0][c1][c2min]; + for (c2 = c2min; c2 <= c2max; c2++) + if (*histp++ != 0) { + boxp->c1max = c1max = c1; + goto have_c1max; + } + } +have_c1max: + if (c2max > c2min) + for (c2 = c2min; c2 <= c2max; c2++) + for (c0 = c0min; c0 <= c0max; c0++) { + histp = &histogram[c0][c1min][c2]; + for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS) + if (*histp != 0) { + boxp->c2min = c2min = c2; + goto have_c2min; + } + } +have_c2min: + if (c2max > c2min) + for (c2 = c2max; c2 >= c2min; c2--) + for (c0 = c0min; c0 <= c0max; c0++) { + histp = &histogram[c0][c1min][c2]; + for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS) + if (*histp != 0) { + boxp->c2max = c2max = c2; + goto have_c2max; + } + } +have_c2max: + + /* Update box volume. + * We use 2-norm rather than real volume here; this biases the method + * against making long narrow boxes, and it has the side benefit that + * a box is splittable iff norm > 0. + * Since the differences are expressed in histogram-cell units, + * we have to shift back to JSAMPLE units to get consistent distances; + * after which, we scale according to the selected distance scale factors. + */ + dist0 = ((c0max - c0min) << C0_SHIFT) * C0_SCALE; + dist1 = ((c1max - c1min) << C1_SHIFT) * C1_SCALE; + dist2 = ((c2max - c2min) << C2_SHIFT) * C2_SCALE; + boxp->volume = dist0 * dist0 + dist1 * dist1 + dist2 * dist2; + + /* Now scan remaining volume of box and compute population */ + ccount = 0; + for (c0 = c0min; c0 <= c0max; c0++) + for (c1 = c1min; c1 <= c1max; c1++) { + histp = &histogram[c0][c1][c2min]; + for (c2 = c2min; c2 <= c2max; c2++, histp++) + if (*histp != 0) { + ccount++; + } + } + boxp->colorcount = ccount; +} + + +LOCAL (int) +median_cut (gdImagePtr oim, gdImagePtr nim, my_cquantize_ptr cquantize, + boxptr boxlist, int numboxes, int desired_colors) +/* Repeatedly select and split the largest box until we have enough boxes */ +{ + int n, lb; + int c0, c1, c2, cmax; + register boxptr b1, b2; + + while (numboxes < desired_colors) { + /* Select box to split. + * Current algorithm: by population for first half, then by volume. + */ + if (numboxes * 2 <= desired_colors) { + b1 = find_biggest_color_pop (boxlist, numboxes); + } else { + b1 = find_biggest_volume (boxlist, numboxes); + } + if (b1 == NULL) /* no splittable boxes left! */ + break; + b2 = &boxlist[numboxes]; /* where new box will go */ + /* Copy the color bounds to the new box. */ + b2->c0max = b1->c0max; + b2->c1max = b1->c1max; + b2->c2max = b1->c2max; + b2->c0min = b1->c0min; + b2->c1min = b1->c1min; + b2->c2min = b1->c2min; + /* Choose which axis to split the box on. + * Current algorithm: longest scaled axis. + * See notes in update_box about scaling distances. + */ + c0 = ((b1->c0max - b1->c0min) << C0_SHIFT) * C0_SCALE; + c1 = ((b1->c1max - b1->c1min) << C1_SHIFT) * C1_SCALE; + c2 = ((b1->c2max - b1->c2min) << C2_SHIFT) * C2_SCALE; + /* We want to break any ties in favor of green, then red, blue last. + * This code does the right thing for R,G,B or B,G,R color orders only. + */ +#if RGB_RED == 0 + cmax = c1; + n = 1; + if (c0 > cmax) { + cmax = c0; + n = 0; + } + if (c2 > cmax) { + n = 2; + } +#else + cmax = c1; + n = 1; + if (c2 > cmax) { + cmax = c2; + n = 2; + } + if (c0 > cmax) { + n = 0; + } +#endif + /* Choose split point along selected axis, and update box bounds. + * Current algorithm: split at halfway point. + * (Since the box has been shrunk to minimum volume, + * any split will produce two nonempty subboxes.) + * Note that lb value is max for lower box, so must be < old max. + */ + switch (n) { + case 0: + lb = (b1->c0max + b1->c0min) / 2; + b1->c0max = lb; + b2->c0min = lb + 1; + break; + case 1: + lb = (b1->c1max + b1->c1min) / 2; + b1->c1max = lb; + b2->c1min = lb + 1; + break; + case 2: + lb = (b1->c2max + b1->c2min) / 2; + b1->c2max = lb; + b2->c2min = lb + 1; + break; + } + /* Update stats for boxes */ + update_box (oim, nim, cquantize, b1); + update_box (oim, nim, cquantize, b2); + numboxes++; + } + return numboxes; +} + + +LOCAL (void) +compute_color (gdImagePtr oim, gdImagePtr nim, my_cquantize_ptr cquantize, + boxptr boxp, int icolor) +{ + hist3d histogram = cquantize->histogram; + histptr histp; + int c0, c1, c2; + int c0min, c0max, c1min, c1max, c2min, c2max; + long count = 0; /* 2.0.28: = 0 */ + long total = 0; + long c0total = 0; + long c1total = 0; + long c2total = 0; + (void)oim; + + c0min = boxp->c0min; + c0max = boxp->c0max; + c1min = boxp->c1min; + c1max = boxp->c1max; + c2min = boxp->c2min; + c2max = boxp->c2max; + + for (c0 = c0min; c0 <= c0max; c0++) + for (c1 = c1min; c1 <= c1max; c1++) { + histp = &histogram[c0][c1][c2min]; + for (c2 = c2min; c2 <= c2max; c2++) { + if ((count = *histp++) != 0) { + total += count; + c0total += + ((c0 << C0_SHIFT) + ((1 << C0_SHIFT) >> 1)) * count; + c1total += + ((c1 << C1_SHIFT) + ((1 << C1_SHIFT) >> 1)) * count; + c2total += + ((c2 << C2_SHIFT) + ((1 << C2_SHIFT) >> 1)) * count; + } + } + } + + /* 2.0.16: Paul den Dulk found an occasion where total can be 0 */ + if (count) { + nim->red[icolor] = (int) ((c0total + (total >> 1)) / total); + nim->green[icolor] = (int) ((c1total + (total >> 1)) / total); + nim->blue[icolor] = (int) ((c2total + (total >> 1)) / total); + } else { + nim->red[icolor] = 255; + nim->green[icolor] = 255; + nim->blue[icolor] = 255; + } + nim->open[icolor] = 0; +} + + +LOCAL (void) +select_colors (gdImagePtr oim, gdImagePtr nim, my_cquantize_ptr cquantize, int desired_colors) +/* Master routine for color selection */ +{ + boxptr boxlist; + int numboxes; + int i; + + /* Allocate workspace for box list */ + /* This can't happen because we clamp desired_colors at gdMaxColors, + but anyway */ + if (overflow2(desired_colors, sizeof (box))) { + return; + } + boxlist = (boxptr) gdMalloc (desired_colors * sizeof (box)); + if (!boxlist) { + return; + } + /* Initialize one box containing whole space */ + numboxes = 1; + boxlist[0].c0min = 0; + boxlist[0].c0max = MAXJSAMPLE >> C0_SHIFT; + boxlist[0].c1min = 0; + boxlist[0].c1max = MAXJSAMPLE >> C1_SHIFT; + boxlist[0].c2min = 0; + boxlist[0].c2max = MAXJSAMPLE >> C2_SHIFT; + /* Shrink it to actually-used volume and set its statistics */ + update_box (oim, nim, cquantize, &boxlist[0]); + /* Perform median-cut to produce final box list */ + numboxes = median_cut (oim, nim, cquantize, boxlist, numboxes, desired_colors); + /* Compute the representative color for each box, fill colormap */ + for (i = 0; i < numboxes; i++) + compute_color (oim, nim, cquantize, &boxlist[i], i); + nim->colorsTotal = numboxes; + + /* If we had a pure transparency color, add it as the last palette entry. + * Skip incrementing the color count so that the dither / matching phase + * won't use it on pixels that shouldn't have been transparent. We'll + * increment it after all that finishes. */ + if (oim->transparent >= 0) { + /* Save the transparent color. */ + nim->red[nim->colorsTotal] = gdTrueColorGetRed (oim->transparent); + nim->green[nim->colorsTotal] = gdTrueColorGetGreen (oim->transparent); + nim->blue[nim->colorsTotal] = gdTrueColorGetBlue (oim->transparent); + nim->alpha[nim->colorsTotal] = gdAlphaTransparent; + nim->open[nim->colorsTotal] = 0; + } + + gdFree (boxlist); +} + + +/* + * These routines are concerned with the time-critical task of mapping input + * colors to the nearest color in the selected colormap. + * + * We re-use the histogram space as an "inverse color map", essentially a + * cache for the results of nearest-color searches. All colors within a + * histogram cell will be mapped to the same colormap entry, namely the one + * closest to the cell's center. This may not be quite the closest entry to + * the actual input color, but it's almost as good. A zero in the cache + * indicates we haven't found the nearest color for that cell yet; the array + * is cleared to zeroes before starting the mapping pass. When we find the + * nearest color for a cell, its colormap index plus one is recorded in the + * cache for future use. The pass2 scanning routines call fill_inverse_cmap + * when they need to use an unfilled entry in the cache. + * + * Our method of efficiently finding nearest colors is based on the "locally + * sorted search" idea described by Heckbert and on the incremental distance + * calculation described by Spencer W. Thomas in chapter III.1 of Graphics + * Gems II (James Arvo, ed. Academic Press, 1991). Thomas points out that + * the distances from a given colormap entry to each cell of the histogram can + * be computed quickly using an incremental method: the differences between + * distances to adjacent cells themselves differ by a constant. This allows a + * fairly fast implementation of the "brute force" approach of computing the + * distance from every colormap entry to every histogram cell. Unfortunately, + * it needs a work array to hold the best-distance-so-far for each histogram + * cell (because the inner loop has to be over cells, not colormap entries). + * The work array elements have to be INT32s, so the work array would need + * 256Kb at our recommended precision. This is not feasible in DOS machines. + * + * To get around these problems, we apply Thomas' method to compute the + * nearest colors for only the cells within a small subbox of the histogram. + * The work array need be only as big as the subbox, so the memory usage + * problem is solved. Furthermore, we need not fill subboxes that are never + * referenced in pass2; many images use only part of the color gamut, so a + * fair amount of work is saved. An additional advantage of this + * approach is that we can apply Heckbert's locality criterion to quickly + * eliminate colormap entries that are far away from the subbox; typically + * three-fourths of the colormap entries are rejected by Heckbert's criterion, + * and we need not compute their distances to individual cells in the subbox. + * The speed of this approach is heavily influenced by the subbox size: too + * small means too much overhead, too big loses because Heckbert's criterion + * can't eliminate as many colormap entries. Empirically the best subbox + * size seems to be about 1/512th of the histogram (1/8th in each direction). + * + * Thomas' article also describes a refined method which is asymptotically + * faster than the brute-force method, but it is also far more complex and + * cannot efficiently be applied to small subboxes. It is therefore not + * useful for programs intended to be portable to DOS machines. On machines + * with plenty of memory, filling the whole histogram in one shot with Thomas' + * refined method might be faster than the present code --- but then again, + * it might not be any faster, and it's certainly more complicated. + */ + + +/* log2(histogram cells in update box) for each axis; this can be adjusted */ +#define BOX_C0_LOG (HIST_C0_BITS-3) +#define BOX_C1_LOG (HIST_C1_BITS-3) +#define BOX_C2_LOG (HIST_C2_BITS-3) + +#define BOX_C0_ELEMS (1<<BOX_C0_LOG) /* # of hist cells in update box */ +#define BOX_C1_ELEMS (1<<BOX_C1_LOG) +#define BOX_C2_ELEMS (1<<BOX_C2_LOG) + +#define BOX_C0_SHIFT (C0_SHIFT + BOX_C0_LOG) +#define BOX_C1_SHIFT (C1_SHIFT + BOX_C1_LOG) +#define BOX_C2_SHIFT (C2_SHIFT + BOX_C2_LOG) + + +/* + * The next three routines implement inverse colormap filling. They could + * all be folded into one big routine, but splitting them up this way saves + * some stack space (the mindist[] and bestdist[] arrays need not coexist) + * and may allow some compilers to produce better code by registerizing more + * inner-loop variables. + */ + +LOCAL (int) +find_nearby_colors ( + gdImagePtr oim, gdImagePtr nim, my_cquantize_ptr cquantize, + int minc0, int minc1, int minc2, JSAMPLE colorlist[]) +/* Locate the colormap entries close enough to an update box to be candidates + * for the nearest entry to some cell(s) in the update box. The update box + * is specified by the center coordinates of its first cell. The number of + * candidate colormap entries is returned, and their colormap indexes are + * placed in colorlist[]. + * This routine uses Heckbert's "locally sorted search" criterion to select + * the colors that need further consideration. + */ +{ + int numcolors = nim->colorsTotal; + int maxc0, maxc1, maxc2; + int centerc0, centerc1, centerc2; + int i, x, ncolors; + INT32 minmaxdist, min_dist, max_dist, tdist; + INT32 mindist[MAXNUMCOLORS]; /* min distance to colormap entry i */ + (void)oim; + (void)cquantize; + + /* Compute true coordinates of update box's upper corner and center. + * Actually we compute the coordinates of the center of the upper-corner + * histogram cell, which are the upper bounds of the volume we care about. + * Note that since ">>" rounds down, the "center" values may be closer to + * min than to max; hence comparisons to them must be "<=", not "<". + */ + maxc0 = minc0 + ((1 << BOX_C0_SHIFT) - (1 << C0_SHIFT)); + centerc0 = (minc0 + maxc0) >> 1; + maxc1 = minc1 + ((1 << BOX_C1_SHIFT) - (1 << C1_SHIFT)); + centerc1 = (minc1 + maxc1) >> 1; + maxc2 = minc2 + ((1 << BOX_C2_SHIFT) - (1 << C2_SHIFT)); + centerc2 = (minc2 + maxc2) >> 1; + + /* For each color in colormap, find: + * 1. its minimum squared-distance to any point in the update box + * (zero if color is within update box); + * 2. its maximum squared-distance to any point in the update box. + * Both of these can be found by considering only the corners of the box. + * We save the minimum distance for each color in mindist[]; + * only the smallest maximum distance is of interest. + */ + minmaxdist = 0x7FFFFFFFL; + + for (i = 0; i < numcolors; i++) { + /* We compute the squared-c0-distance term, then add in the other two. */ + x = nim->red[i]; + if (x < minc0) { + tdist = (x - minc0) * C0_SCALE; + min_dist = tdist * tdist; + tdist = (x - maxc0) * C0_SCALE; + max_dist = tdist * tdist; + } else if (x > maxc0) { + tdist = (x - maxc0) * C0_SCALE; + min_dist = tdist * tdist; + tdist = (x - minc0) * C0_SCALE; + max_dist = tdist * tdist; + } else { + /* within cell range so no contribution to min_dist */ + min_dist = 0; + if (x <= centerc0) { + tdist = (x - maxc0) * C0_SCALE; + max_dist = tdist * tdist; + } else { + tdist = (x - minc0) * C0_SCALE; + max_dist = tdist * tdist; + } + } + + x = nim->green[i]; + if (x < minc1) { + tdist = (x - minc1) * C1_SCALE; + min_dist += tdist * tdist; + tdist = (x - maxc1) * C1_SCALE; + max_dist += tdist * tdist; + } else if (x > maxc1) { + tdist = (x - maxc1) * C1_SCALE; + min_dist += tdist * tdist; + tdist = (x - minc1) * C1_SCALE; + max_dist += tdist * tdist; + } else { + /* within cell range so no contribution to min_dist */ + if (x <= centerc1) { + tdist = (x - maxc1) * C1_SCALE; + max_dist += tdist * tdist; + } else { + tdist = (x - minc1) * C1_SCALE; + max_dist += tdist * tdist; + } + } + + x = nim->blue[i]; + if (x < minc2) { + tdist = (x - minc2) * C2_SCALE; + min_dist += tdist * tdist; + tdist = (x - maxc2) * C2_SCALE; + max_dist += tdist * tdist; + } else if (x > maxc2) { + tdist = (x - maxc2) * C2_SCALE; + min_dist += tdist * tdist; + tdist = (x - minc2) * C2_SCALE; + max_dist += tdist * tdist; + } else { + /* within cell range so no contribution to min_dist */ + if (x <= centerc2) { + tdist = (x - maxc2) * C2_SCALE; + max_dist += tdist * tdist; + } else { + tdist = (x - minc2) * C2_SCALE; + max_dist += tdist * tdist; + } + } + + mindist[i] = min_dist; /* save away the results */ + if (max_dist < minmaxdist) + minmaxdist = max_dist; + } + + /* Now we know that no cell in the update box is more than minmaxdist + * away from some colormap entry. Therefore, only colors that are + * within minmaxdist of some part of the box need be considered. + */ + ncolors = 0; + for (i = 0; i < numcolors; i++) { + if (mindist[i] <= minmaxdist) + colorlist[ncolors++] = (JSAMPLE) i; + } + return ncolors; +} + + +LOCAL (void) find_best_colors ( + gdImagePtr oim, gdImagePtr nim, my_cquantize_ptr cquantize, + int minc0, int minc1, int minc2, + int numcolors, JSAMPLE colorlist[], + JSAMPLE bestcolor[]) +/* Find the closest colormap entry for each cell in the update box, + * given the list of candidate colors prepared by find_nearby_colors. + * Return the indexes of the closest entries in the bestcolor[] array. + * This routine uses Thomas' incremental distance calculation method to + * find the distance from a colormap entry to successive cells in the box. + */ +{ + int ic0, ic1, ic2; + int i, icolor; + register INT32 *bptr; /* pointer into bestdist[] array */ + JSAMPLE *cptr; /* pointer into bestcolor[] array */ + INT32 dist0, dist1; /* initial distance values */ + register INT32 dist2; /* current distance in inner loop */ + INT32 xx0, xx1; /* distance increments */ + register INT32 xx2; + INT32 inc0, inc1, inc2; /* initial values for increments */ + /* This array holds the distance to the nearest-so-far color for each cell */ + INT32 bestdist[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS]; + (void)oim; + (void)cquantize; + + /* Initialize best-distance for each cell of the update box */ + bptr = bestdist; + for (i = BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS - 1; i >= 0; i--) + *bptr++ = 0x7FFFFFFFL; + + /* For each color selected by find_nearby_colors, + * compute its distance to the center of each cell in the box. + * If that's less than best-so-far, update best distance and color number. + */ + + /* Nominal steps between cell centers ("x" in Thomas article) */ +#define STEP_C0 ((1 << C0_SHIFT) * C0_SCALE) +#define STEP_C1 ((1 << C1_SHIFT) * C1_SCALE) +#define STEP_C2 ((1 << C2_SHIFT) * C2_SCALE) + + for (i = 0; i < numcolors; i++) { + int r, g, b; + icolor = colorlist[i]; + r = nim->red[icolor]; + g = nim->green[icolor]; + b = nim->blue[icolor]; + + /* Compute (square of) distance from minc0/c1/c2 to this color */ + inc0 = (minc0 - r) * C0_SCALE; + dist0 = inc0 * inc0; + inc1 = (minc1 - g) * C1_SCALE; + dist0 += inc1 * inc1; + inc2 = (minc2 - b) * C2_SCALE; + dist0 += inc2 * inc2; + /* Form the initial difference increments */ + inc0 = inc0 * (2 * STEP_C0) + STEP_C0 * STEP_C0; + inc1 = inc1 * (2 * STEP_C1) + STEP_C1 * STEP_C1; + inc2 = inc2 * (2 * STEP_C2) + STEP_C2 * STEP_C2; + /* Now loop over all cells in box, updating distance per Thomas method */ + bptr = bestdist; + cptr = bestcolor; + xx0 = inc0; + for (ic0 = BOX_C0_ELEMS - 1; ic0 >= 0; ic0--) { + dist1 = dist0; + xx1 = inc1; + for (ic1 = BOX_C1_ELEMS - 1; ic1 >= 0; ic1--) { + dist2 = dist1; + xx2 = inc2; + for (ic2 = BOX_C2_ELEMS - 1; ic2 >= 0; ic2--) { + if (dist2 < *bptr) { + *bptr = dist2; + *cptr = (JSAMPLE) icolor; + } + dist2 += xx2; + xx2 += 2 * STEP_C2 * STEP_C2; + bptr++; + cptr++; + } + dist1 += xx1; + xx1 += 2 * STEP_C1 * STEP_C1; + } + dist0 += xx0; + xx0 += 2 * STEP_C0 * STEP_C0; + } + } +} + + +LOCAL (void) +fill_inverse_cmap ( + gdImagePtr oim, gdImagePtr nim, my_cquantize_ptr cquantize, + int c0, int c1, int c2) +/* Fill the inverse-colormap entries in the update box that contains */ +/* histogram cell c0/c1/c2. (Only that one cell MUST be filled, but */ +/* we can fill as many others as we wish.) */ +{ + hist3d histogram = cquantize->histogram; + int minc0, minc1, minc2; /* lower left corner of update box */ + int ic0, ic1, ic2; + register JSAMPLE *cptr; /* pointer into bestcolor[] array */ + register histptr cachep; /* pointer into main cache array */ + /* This array lists the candidate colormap indexes. */ + JSAMPLE colorlist[MAXNUMCOLORS]; + int numcolors; /* number of candidate colors */ + /* This array holds the actually closest colormap index for each cell. */ + JSAMPLE bestcolor[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS]; + + /* Convert cell coordinates to update box ID */ + c0 >>= BOX_C0_LOG; + c1 >>= BOX_C1_LOG; + c2 >>= BOX_C2_LOG; + + /* Compute true coordinates of update box's origin corner. + * Actually we compute the coordinates of the center of the corner + * histogram cell, which are the lower bounds of the volume we care about. + */ + minc0 = (c0 << BOX_C0_SHIFT) + ((1 << C0_SHIFT) >> 1); + minc1 = (c1 << BOX_C1_SHIFT) + ((1 << C1_SHIFT) >> 1); + minc2 = (c2 << BOX_C2_SHIFT) + ((1 << C2_SHIFT) >> 1); + + /* Determine which colormap entries are close enough to be candidates + * for the nearest entry to some cell in the update box. + */ + numcolors = + find_nearby_colors (oim, nim, cquantize, minc0, minc1, minc2, colorlist); + find_best_colors (oim, nim, cquantize, minc0, minc1, minc2, numcolors, + colorlist, bestcolor); + + /* Save the best color numbers (plus 1) in the main cache array */ + c0 <<= BOX_C0_LOG; /* convert ID back to base cell indexes */ + c1 <<= BOX_C1_LOG; + c2 <<= BOX_C2_LOG; + cptr = bestcolor; + for (ic0 = 0; ic0 < BOX_C0_ELEMS; ic0++) { + for (ic1 = 0; ic1 < BOX_C1_ELEMS; ic1++) { + cachep = &histogram[c0 + ic0][c1 + ic1][c2]; + for (ic2 = 0; ic2 < BOX_C2_ELEMS; ic2++) { + *cachep++ = (histcell) ((*cptr++) + 1); + } + } + } +} + + +/* + * Map some rows of pixels to the output colormapped representation. + */ + +METHODDEF (void) +pass2_no_dither (gdImagePtr oim, gdImagePtr nim, my_cquantize_ptr cquantize) +{ + register int *inptr; + register unsigned char *outptr; + int width = oim->sx; + int num_rows = oim->sy; + hist3d histogram = cquantize->histogram; + register int c0, c1, c2; + int row; + JDIMENSION col; + register histptr cachep; + + + for (row = 0; row < num_rows; row++) { + inptr = input_buf[row]; + outptr = output_buf[row]; + for (col = width; col > 0; col--) { + /* get pixel value and index into the cache */ + int r, g, b; + r = gdTrueColorGetRed (*inptr); + g = gdTrueColorGetGreen (*inptr); + /* + 2.0.24: inptr must not be incremented until after + transparency check, if any. Thanks to "Super Pikeman." + */ + b = gdTrueColorGetBlue (*inptr); + + /* If the pixel is transparent, we assign it the palette index that + * will later be added at the end of the palette as the transparent + * index. */ + if ((oim->transparent >= 0) && (oim->transparent == *inptr)) { + *outptr++ = nim->colorsTotal; + inptr++; + continue; + } + inptr++; + c0 = r >> C0_SHIFT; + c1 = g >> C1_SHIFT; + c2 = b >> C2_SHIFT; + cachep = &histogram[c0][c1][c2]; + /* If we have not seen this color before, find nearest colormap entry */ + /* and update the cache */ + if (*cachep == 0) + fill_inverse_cmap (oim, nim, cquantize, c0, c1, c2); + /* Now emit the colormap index for this cell */ + *outptr++ = (*cachep - 1); + } + } +} + + +METHODDEF (void) +pass2_fs_dither (gdImagePtr oim, gdImagePtr nim, my_cquantize_ptr cquantize) +{ + hist3d histogram = cquantize->histogram; + register LOCFSERROR cur0, cur1, cur2; /* current error or pixel value */ + LOCFSERROR belowerr0, belowerr1, belowerr2; /* error for pixel below cur */ + LOCFSERROR bpreverr0, bpreverr1, bpreverr2; /* error for below/prev col */ + register FSERRPTR errorptr; /* => fserrors[] at column before current */ + histptr cachep; + int dir; /* +1 or -1 depending on direction */ + int dir3; /* 3*dir, for advancing inptr & errorptr */ + int row; + JDIMENSION col; + int *inptr; /* => current input pixel */ + unsigned char *outptr; /* => current output pixel */ + int width = oim->sx; + int num_rows = oim->sy; + int *colormap0 = nim->red; + int *colormap1 = nim->green; + int *colormap2 = nim->blue; + int *error_limit = cquantize->error_limiter; + + + SHIFT_TEMPS for (row = 0; row < num_rows; row++) { + inptr = input_buf[row]; + outptr = output_buf[row]; + if (cquantize->on_odd_row) { + /* work right to left in this row */ + inptr += (width - 1) * 3; /* so point to rightmost pixel */ + outptr += width - 1; + dir = -1; + dir3 = -3; + errorptr = cquantize->fserrors + (width + 1) * 3; /* => entry after last column */ + } else { + /* work left to right in this row */ + dir = 1; + dir3 = 3; + errorptr = cquantize->fserrors; /* => entry before first real column */ + } + /* Preset error values: no error propagated to first pixel from left */ + cur0 = cur1 = cur2 = 0; + /* and no error propagated to row below yet */ + belowerr0 = belowerr1 = belowerr2 = 0; + bpreverr0 = bpreverr1 = bpreverr2 = 0; + + for (col = width; col > 0; col--) { + + /* If this pixel is transparent, we want to assign it to the special + * transparency color index past the end of the palette rather than + * go through matching / dithering. */ + if ((oim->transparent >= 0) && (*inptr == oim->transparent)) { + *outptr = nim->colorsTotal; + errorptr[0] = 0; + errorptr[1] = 0; + errorptr[2] = 0; + errorptr[3] = 0; + inptr += dir; + outptr += dir; + errorptr += dir3; + continue; + } + /* curN holds the error propagated from the previous pixel on the + * current line. Add the error propagated from the previous line + * to form the complete error correction term for this pixel, and + * round the error term (which is expressed * 16) to an integer. + * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct + * for either sign of the error value. + * Note: errorptr points to *previous* column's array entry. + */ + cur0 = RIGHT_SHIFT (cur0 + errorptr[dir3 + 0] + 8, 4); + cur1 = RIGHT_SHIFT (cur1 + errorptr[dir3 + 1] + 8, 4); + cur2 = RIGHT_SHIFT (cur2 + errorptr[dir3 + 2] + 8, 4); + /* Limit the error using transfer function set by init_error_limit. + * See comments with init_error_limit for rationale. + */ + cur0 = error_limit[cur0]; + cur1 = error_limit[cur1]; + cur2 = error_limit[cur2]; + /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE. + * The maximum error is +- MAXJSAMPLE (or less with error limiting); + * this sets the required size of the range_limit array. + */ + cur0 += gdTrueColorGetRed (*inptr); + cur1 += gdTrueColorGetGreen (*inptr); + cur2 += gdTrueColorGetBlue (*inptr); + range_limit (cur0); + range_limit (cur1); + range_limit (cur2); + + /* Index into the cache with adjusted pixel value */ + cachep = + &histogram[cur0 >> C0_SHIFT][cur1 >> C1_SHIFT][cur2 >> C2_SHIFT]; + /* If we have not seen this color before, find nearest colormap */ + /* entry and update the cache */ + if (*cachep == 0) + fill_inverse_cmap (oim, nim, cquantize, cur0 >> C0_SHIFT, + cur1 >> C1_SHIFT, cur2 >> C2_SHIFT); + /* Now emit the colormap index for this cell */ + { + register int pixcode = *cachep - 1; + *outptr = (JSAMPLE) pixcode; + /* Compute representation error for this pixel */ +#define GETJSAMPLE + cur0 -= GETJSAMPLE (colormap0[pixcode]); + cur1 -= GETJSAMPLE (colormap1[pixcode]); + cur2 -= GETJSAMPLE (colormap2[pixcode]); +#undef GETJSAMPLE + } + /* Compute error fractions to be propagated to adjacent pixels. + * Add these into the running sums, and simultaneously shift the + * next-line error sums left by 1 column. + */ + { + register LOCFSERROR bnexterr, delta; + + bnexterr = cur0; /* Process component 0 */ + delta = cur0 * 2; + cur0 += delta; /* form error * 3 */ + errorptr[0] = (FSERROR) (bpreverr0 + cur0); + cur0 += delta; /* form error * 5 */ + bpreverr0 = belowerr0 + cur0; + belowerr0 = bnexterr; + cur0 += delta; /* form error * 7 */ + bnexterr = cur1; /* Process component 1 */ + delta = cur1 * 2; + cur1 += delta; /* form error * 3 */ + errorptr[1] = (FSERROR) (bpreverr1 + cur1); + cur1 += delta; /* form error * 5 */ + bpreverr1 = belowerr1 + cur1; + belowerr1 = bnexterr; + cur1 += delta; /* form error * 7 */ + bnexterr = cur2; /* Process component 2 */ + delta = cur2 * 2; + cur2 += delta; /* form error * 3 */ + errorptr[2] = (FSERROR) (bpreverr2 + cur2); + cur2 += delta; /* form error * 5 */ + bpreverr2 = belowerr2 + cur2; + belowerr2 = bnexterr; + cur2 += delta; /* form error * 7 */ + } + /* At this point curN contains the 7/16 error value to be propagated + * to the next pixel on the current line, and all the errors for the + * next line have been shifted over. We are therefore ready to move on. + */ + inptr += dir; /* Advance pixel pointers to next column */ + outptr += dir; + errorptr += dir3; /* advance errorptr to current column */ + } + /* Post-loop cleanup: we must unload the final error values into the + * final fserrors[] entry. Note we need not unload belowerrN because + * it is for the dummy column before or after the actual array. + */ + errorptr[0] = (FSERROR) bpreverr0; /* unload prev errs into array */ + errorptr[1] = (FSERROR) bpreverr1; + errorptr[2] = (FSERROR) bpreverr2; + } +} + + +/* + * Initialize the error-limiting transfer function (lookup table). + * The raw F-S error computation can potentially compute error values of up to + * +- MAXJSAMPLE. But we want the maximum correction applied to a pixel to be + * much less, otherwise obviously wrong pixels will be created. (Typical + * effects include weird fringes at color-area boundaries, isolated bright + * pixels in a dark area, etc.) The standard advice for avoiding this problem + * is to ensure that the "corners" of the color cube are allocated as output + * colors; then repeated errors in the same direction cannot cause cascading + * error buildup. However, that only prevents the error from getting + * completely out of hand; Aaron Giles reports that error limiting improves + * the results even with corner colors allocated. + * A simple clamping of the error values to about +- MAXJSAMPLE/8 works pretty + * well, but the smoother transfer function used below is even better. Thanks + * to Aaron Giles for this idea. + */ + +LOCAL (void) +init_error_limit (gdImagePtr oim, gdImagePtr nim, my_cquantize_ptr cquantize) +/* Allocate and fill in the error_limiter table */ +{ + int *table; + int in, out; + (void)oim; + (void)nim; + + cquantize->error_limiter_storage = + (int *) gdMalloc ((MAXJSAMPLE * 2 + 1) * sizeof (int)); + if (!cquantize->error_limiter_storage) { + return; + } + table = cquantize->error_limiter_storage; + + table += MAXJSAMPLE; /* so can index -MAXJSAMPLE .. +MAXJSAMPLE */ + cquantize->error_limiter = table; + +#define STEPSIZE ((MAXJSAMPLE+1)/16) + /* Map errors 1:1 up to +- MAXJSAMPLE/16 */ + out = 0; + for (in = 0; in < STEPSIZE; in++, out++) { + table[in] = out; + table[-in] = -out; + } + /* Map errors 1:2 up to +- 3*MAXJSAMPLE/16 */ + for (; in < STEPSIZE * 3; in++, out += (in & 1) ? 0 : 1) { + table[in] = out; + table[-in] = -out; + } + /* Clamp the rest to final out value (which is (MAXJSAMPLE+1)/8) */ + for (; in <= MAXJSAMPLE; in++) { + table[in] = out; + table[-in] = -out; + } +#undef STEPSIZE +} + + +/* + * Finish up at the end of each pass. + */ + +static void +zeroHistogram (hist3d histogram) +{ + int i; + /* Zero the histogram or inverse color map */ + for (i = 0; i < HIST_C0_ELEMS; i++) { + memset (histogram[i], + 0, HIST_C1_ELEMS * HIST_C2_ELEMS * sizeof (histcell)); + } +} + + +/* + Selects quantization method used for subsequent gdImageTrueColorToPalette calls. + See gdPaletteQuantizationMethod enum (e.g. GD_QUANT_NEUQUANT, GD_QUANT_LIQ). + Speed is from 1 (highest quality) to 10 (fastest). + Speed 0 selects method-specific default (recommended). + + Returns FALSE if the given method is invalid or not available. +*/ +BGD_DECLARE(int) gdImageTrueColorToPaletteSetMethod (gdImagePtr im, int method, int speed) +{ +#ifndef HAVE_LIBIMAGEQUANT_H + if (method == GD_QUANT_LIQ) { + return FALSE; + } +#endif + + if (method >= GD_QUANT_DEFAULT && method <= GD_QUANT_LIQ) { + im->paletteQuantizationMethod = method; + + if (speed < 0 || speed > 10) { + speed = 0; + } + im->paletteQuantizationSpeed = speed; + } + return TRUE; +} + +/* + Chooses quality range that subsequent call to gdImageTrueColorToPalette will aim for. + Min and max quality is in range 1-100 (1 = ugly, 100 = perfect). Max must be higher than min. + If palette cannot represent image with at least min_quality, then image will remain true-color. + If palette can represent image with quality better than max_quality, then lower number of colors will be used. + This function has effect only when GD_QUANT_LIQ method has been selected. +*/ +BGD_DECLARE(void) gdImageTrueColorToPaletteSetQuality (gdImagePtr im, int min_quality, int max_quality) +{ + if (min_quality >= 0 && min_quality <= 100 && + max_quality >= 0 && max_quality <= 100 && min_quality <= max_quality) { + im->paletteQuantizationMinQuality = min_quality; + im->paletteQuantizationMaxQuality = max_quality; + } +} + +static int gdImageTrueColorToPaletteBody (gdImagePtr oim, int dither, int colorsWanted, gdImagePtr *cimP); + +BGD_DECLARE(gdImagePtr) gdImageCreatePaletteFromTrueColor (gdImagePtr im, int dither, int colorsWanted) +{ + gdImagePtr nim; + if (TRUE == gdImageTrueColorToPaletteBody(im, dither, colorsWanted, &nim)) { + return nim; + } + return NULL; +} + +BGD_DECLARE(int) gdImageTrueColorToPalette (gdImagePtr im, int dither, int colorsWanted) +{ + return gdImageTrueColorToPaletteBody(im, dither, colorsWanted, 0); +} + +#ifdef HAVE_LIBIMAGEQUANT_H +/** + LIQ library needs pixels in RGBA order with alpha 0-255 (opaque 255). + This callback is run whenever source rows need to be converted from GD's format. +*/ +static void convert_gdpixel_to_rgba(liq_color output_row[], int y, int width, void *userinfo) +{ + gdImagePtr oim = userinfo; + int x; + for(x = 0; x < width; x++) { + output_row[x].r = gdTrueColorGetRed(input_buf[y][x]) * 255/gdRedMax; + output_row[x].g = gdTrueColorGetGreen(input_buf[y][x]) * 255/gdGreenMax; + output_row[x].b = gdTrueColorGetBlue(input_buf[y][x]) * 255/gdBlueMax; + int alpha = gdTrueColorGetAlpha(input_buf[y][x]); + if (gdAlphaOpaque < gdAlphaTransparent) { + alpha = gdAlphaTransparent - alpha; + } + output_row[x].a = alpha * 255/gdAlphaMax; + } +} +#endif + +static void free_truecolor_image_data(gdImagePtr oim) +{ + int i; + oim->trueColor = 0; + /* Junk the truecolor pixels */ + for (i = 0; i < oim->sy; i++) { + gdFree (oim->tpixels[i]); + } + gdFree (oim->tpixels); + oim->tpixels = 0; +} + +/* + * Module initialization routine for 2-pass color quantization. + */ + +static int gdImageTrueColorToPaletteBody (gdImagePtr oim, int dither, int colorsWanted, gdImagePtr *cimP) +{ + my_cquantize_ptr cquantize = NULL; + int i, conversionSucceeded=0; + + /* Allocate the JPEG palette-storage */ + size_t arraysize; + int maxColors = gdMaxColors; + gdImagePtr nim; + + if (cimP) { + nim = gdImageCreate(oim->sx, oim->sy); + *cimP = nim; + if (!nim) { + return FALSE; + } + } else { + nim = oim; + } + + if (!oim->trueColor) { + /* (Almost) nothing to do! */ + if (cimP) { + gdImageCopy(nim, oim, 0, 0, 0, 0, oim->sx, oim->sy); + *cimP = nim; + } + return TRUE; + } + + /* If we have a transparent color (the alphaless mode of transparency), we + * must reserve a palette entry for it at the end of the palette. */ + if (oim->transparent >= 0) { + maxColors--; + } + if (colorsWanted > maxColors) { + colorsWanted = maxColors; + } + if (!cimP) { + nim->pixels = gdCalloc (sizeof (unsigned char *), oim->sy); + if (!nim->pixels) { + /* No can do */ + goto outOfMemory; + } + for (i = 0; (i < nim->sy); i++) { + nim->pixels[i] = (unsigned char *) gdCalloc (sizeof (unsigned char *), oim->sx); + if (!nim->pixels[i]) { + goto outOfMemory; + } + } + } + + + if (oim->paletteQuantizationMethod == GD_QUANT_NEUQUANT) { + if (cimP) { /* NeuQuant alwasy creates a copy, so the new blank image can't be used */ + gdImageDestroy(nim); + } + nim = gdImageNeuQuant(oim, colorsWanted, oim->paletteQuantizationSpeed ? oim->paletteQuantizationSpeed : 2); + if (cimP) { + *cimP = nim; + } else { + gdImageCopy(oim, nim, 0, 0, 0, 0, oim->sx, oim->sy); + gdImageDestroy(nim); + } + return TRUE; + } + + +#ifdef HAVE_LIBIMAGEQUANT_H + if (oim->paletteQuantizationMethod == GD_QUANT_DEFAULT || + oim->paletteQuantizationMethod == GD_QUANT_LIQ) { + liq_attr *attr = liq_attr_create_with_allocator(gdMalloc, gdFree); + liq_image *image; + liq_result *remap; + int remapped_ok = 0; + + liq_set_max_colors(attr, colorsWanted); + + /* by default make it fast to match speed of previous implementation */ + liq_set_speed(attr, oim->paletteQuantizationSpeed ? oim->paletteQuantizationSpeed : 9); + if (oim->paletteQuantizationMaxQuality) { + liq_set_quality(attr, oim->paletteQuantizationMinQuality, oim->paletteQuantizationMaxQuality); + } + image = liq_image_create_custom(attr, convert_gdpixel_to_rgba, oim, oim->sx, oim->sy, 0); + remap = liq_quantize_image(attr, image); + if (!remap) { /* minimum quality not met, leave image unmodified */ + liq_image_destroy(image); + liq_attr_destroy(attr); + goto outOfMemory; + } + + liq_set_dithering_level(remap, dither ? 1 : 0); + if (LIQ_OK == liq_write_remapped_image_rows(remap, image, output_buf)) { + remapped_ok = 1; + const liq_palette *pal = liq_get_palette(remap); + nim->transparent = -1; + unsigned int icolor; + for(icolor=0; icolor < pal->count; icolor++) { + nim->open[icolor] = 0; + nim->red[icolor] = pal->entries[icolor].r * gdRedMax/255; + nim->green[icolor] = pal->entries[icolor].g * gdGreenMax/255; + nim->blue[icolor] = pal->entries[icolor].b * gdBlueMax/255; + int alpha = pal->entries[icolor].a * gdAlphaMax/255; + if (gdAlphaOpaque < gdAlphaTransparent) { + alpha = gdAlphaTransparent - alpha; + } + nim->alpha[icolor] = alpha; + if (nim->transparent == -1 && alpha == gdAlphaTransparent) { + nim->transparent = icolor; + } + } + nim->colorsTotal = pal->count; + } + liq_result_destroy(remap); + liq_image_destroy(image); + liq_attr_destroy(attr); + + if (remapped_ok) { + if (!cimP) { + free_truecolor_image_data(oim); + } + return TRUE; + } + } +#endif + + cquantize = (my_cquantize_ptr) gdCalloc (sizeof (my_cquantizer), 1); + if (!cquantize) { + /* No can do */ + goto outOfMemory; + } + cquantize->fserrors = NULL; /* flag optional arrays not allocated */ + cquantize->error_limiter = NULL; + + + /* Allocate the histogram/inverse colormap storage */ + cquantize->histogram = (hist3d) gdMalloc (HIST_C0_ELEMS * sizeof (hist2d)); + for (i = 0; i < HIST_C0_ELEMS; i++) { + cquantize->histogram[i] = + (hist2d) gdMalloc (HIST_C1_ELEMS * HIST_C2_ELEMS * sizeof (histcell)); + if (!cquantize->histogram[i]) { + goto outOfMemory; + } + } + + + cquantize->fserrors = (FSERRPTR) gdMalloc (3 * sizeof (FSERROR)); + init_error_limit (oim, nim, cquantize); + arraysize = (size_t) ((nim->sx + 2) * (3 * sizeof (FSERROR))); + /* Allocate Floyd-Steinberg workspace. */ + cquantize->fserrors = gdReallocEx(cquantize->fserrors, arraysize); + if (!cquantize->fserrors) { + goto outOfMemory; + } + memset(cquantize->fserrors, 0, arraysize); + cquantize->on_odd_row = FALSE; + + /* Do the work! */ + zeroHistogram (cquantize->histogram); + prescan_quantize (oim, nim, cquantize); + /* TBB 2.0.5: pass colorsWanted, not 256! */ + select_colors (oim, nim, cquantize, colorsWanted); + zeroHistogram (cquantize->histogram); + if (dither) { + pass2_fs_dither (oim, nim, cquantize); + } else { + pass2_no_dither (oim, nim, cquantize); + } +#if 0 /* 2.0.12; we no longer attempt full alpha in palettes */ + if (cquantize->transparentIsPresent) { + int mt = -1; + int mtIndex = -1; + for (i = 0; (i < im->colorsTotal); i++) { + if (im->alpha[i] > mt) { + mtIndex = i; + mt = im->alpha[i]; + } + } + for (i = 0; (i < im->colorsTotal); i++) { + if (im->alpha[i] == mt) { + im->alpha[i] = gdAlphaTransparent; + } + } + } + if (cquantize->opaqueIsPresent) { + int mo = 128; + int moIndex = -1; + for (i = 0; (i < im->colorsTotal); i++) { + if (im->alpha[i] < mo) { + moIndex = i; + mo = im->alpha[i]; + } + } + for (i = 0; (i < im->colorsTotal); i++) { + if (im->alpha[i] == mo) { + im->alpha[i] = gdAlphaOpaque; + } + } + } +#endif + + /* If we had a 'transparent' color, increment the color count so it's + * officially in the palette and convert the transparent variable to point to + * an index rather than a color (Its data already exists and transparent + * pixels have already been mapped to it by this point, it is done late as to + * avoid color matching / dithering with it). */ + if (oim->transparent >= 0) { + nim->transparent = nim->colorsTotal; + nim->colorsTotal++; + } + + /* Success! Get rid of the truecolor image data. */ + conversionSucceeded = TRUE; + if (!cimP) { + free_truecolor_image_data(oim); + } + + goto freeQuantizeData; + /* Tediously free stuff. */ +outOfMemory: + conversionSucceeded = FALSE; + if (oim->trueColor) { + if (!cimP) { + /* On failure only */ + if (nim->pixels) { + for (i = 0; i < nim->sy; i++) { + if (nim->pixels[i]) { + gdFree (nim->pixels[i]); + } + } + gdFree (nim->pixels); + } + nim->pixels = NULL; + } else { + gdImageDestroy(nim); + *cimP = 0; + } + } + +freeQuantizeData: + if (cquantize) { + if (cquantize->histogram) { + for (i = 0; i < HIST_C0_ELEMS; i++) { + if (cquantize->histogram[i]) { + gdFree (cquantize->histogram[i]); + } + } + gdFree (cquantize->histogram); + } + if (cquantize->fserrors) { + gdFree (cquantize->fserrors); + } + if (cquantize->error_limiter_storage) { + gdFree (cquantize->error_limiter_storage); + } + gdFree (cquantize); + } + + return conversionSucceeded; +} + +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_transform.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_transform.c new file mode 100644 index 00000000000..68013ef9319 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_transform.c @@ -0,0 +1,77 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif /* HAVE_CONFIG_H */ + +#include "gd.h" + +BGD_DECLARE(void) gdImageFlipVertical(gdImagePtr im) +{ + register int x, y; + + if (im->trueColor) { + for (y = 0; y < im->sy / 2; y++) { + int *row_dst = im->tpixels[y]; + int *row_src = im->tpixels[im->sy - 1 - y]; + for (x = 0; x < im->sx; x++) { + register int p; + p = row_dst[x]; + row_dst[x] = im->tpixels[im->sy - 1 - y][x]; + row_src[x] = p; + } + } + } else { + unsigned char p; + for (y = 0; y < im->sy / 2; y++) { + for (x = 0; x < im->sx; x++) { + p = im->tpixels[y][x]; + im->tpixels[y][x] = im->tpixels[im->sy - 1 - y][x]; + im->tpixels[im->sy - 1 - y][x] = p; + } + } + } + return; +} + +BGD_DECLARE(void) gdImageFlipHorizontal(gdImagePtr im) +{ + + int x, y; + + if (im->trueColor) { + int *px1, *px2, tmp; + + for (y = 0; y < im->sy; y++) { + px1 = im->tpixels[y]; + px2 = im->tpixels[y] + im->sx - 1; + for (x = 0; x < (im->sx >> 1); x++) { + tmp = *px1; + *px1 = *px2; + *px2 = tmp; + px1++; + px2--; + } + } + } else { + unsigned char *px1, *px2, tmp; + + for (y = 0; y < im->sy; y++) { + px1 = im->pixels[y]; + px2 = im->pixels[y] + im->sx - 1; + for (x = 0; x < (im->sx >> 1); x++) { + tmp = *px1; + *px1 = *px2; + *px2 = tmp; + px1++; + px2--; + } + } + } +} + +BGD_DECLARE(void) gdImageFlipBoth(gdImagePtr im) +{ + gdImageFlipVertical(im); + gdImageFlipHorizontal(im); +} + + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_version.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_version.c new file mode 100644 index 00000000000..222d428ce7b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_version.c @@ -0,0 +1,33 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif /* HAVE_CONFIG_H */ + +#include "gd.h" + + +/* These functions return the version information. We use functions + * so that changes in the shared library will automatically be + * reflected in executables using it without recompiling them. */ + +BGD_DECLARE(int) gdMajorVersion() +{ + return GD_MAJOR_VERSION; +} + +BGD_DECLARE(int) gdMinorVersion() +{ + return GD_MINOR_VERSION; +} + +BGD_DECLARE(int) gdReleaseVersion() +{ + return GD_RELEASE_VERSION; +} + +BGD_DECLARE(const char *) gdExtraVersion() { + return GD_EXTRA_VERSION; +} + +BGD_DECLARE(const char *) gdVersionString() { + return GD_VERSION_STRING; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_wbmp.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_wbmp.c new file mode 100644 index 00000000000..53fbdc2d1a8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_wbmp.c @@ -0,0 +1,266 @@ +/* + * WBMP: Wireless Bitmap Type 0: B/W, Uncompressed Bitmap + * Specification of the WBMP format can be found in the file: + * SPEC-WAESpec-19990524.pdf + * You can download the WAP specification on: http://www.wapforum.com/ + * + * gd_wbmp.c + * + * Copyright (C) Johan Van den Brande (johan@vandenbrande.com) + * + * Fixed: gdImageWBMPPtr, gdImageWBMP + * + * Recoded: gdImageWBMPCtx for use with my wbmp library + * (wbmp library included, but you can find the latest distribution + * at http://www.vandenbrande.com/wbmp) + * + * Implemented: gdImageCreateFromWBMPCtx, gdImageCreateFromWBMP + * + *-------------------------------------------------------------------------- + * + * Parts of this code are from Maurice Smurlo. + * + ** Copyright (C) Maurice Szmurlo --- T-SIT --- January 2000 + ** (Maurice.Szmurlo@info.unicaen.fr) + ** + ** Permission to use, copy, modify, and distribute this software and its + ** documentation for any purpose and without fee is hereby granted, provided + ** that the above copyright notice appear in all copies and that both that + ** copyright notice and this permission notice appear in supporting + ** documentation. This software is provided "as is" without express or + ** implied warranty. + * + *-------------------------------------------------------------------------- + * + * Parts of this code are inspired by 'pbmtowbmp.c' and 'wbmptopbm.c' by + * Terje Sannum <terje@looplab.com>. + * + ** Permission to use, copy, modify, and distribute this software and its + ** documentation for any purpose and without fee is hereby granted, provided + ** that the above copyright notice appear in all copies and that both that + ** copyright notice and this permission notice appear in supporting + ** documentation. This software is provided "as is" without express or + ** implied warranty. + * + *-------------------------------------------------------------------------- + * + * Todo: + * + * gdCreateFromWBMP function for reading WBMP files + * + *-------------------------------------------------------------------------- + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "gd.h" +#include "gd_errors.h" +#include "gdfonts.h" +#include <stdio.h> +#include <stdlib.h> +#include <limits.h> + +#include "wbmp.h" + +/* gd_putout + * --------- + * Wrapper around gdPutC for use with writewbmp + */ +void gd_putout(int i, void *out) +{ + gdPutC(i, (gdIOCtx *)out); +} + +/* gd_getin + * -------- + * Wrapper around gdGetC for use with readwbmp + */ +int gd_getin(void *in) +{ + return (gdGetC((gdIOCtx *)in)); +} + +/* gdImageWBMPCtx + * -------------- + * Write the image as a wbmp file + * Parameters are: + * image: gd image structure; + * fg: the index of the foreground color. any other value will be + * considered as background and will not be written + * out: the stream where to write + */ +BGD_DECLARE(void) gdImageWBMPCtx(gdImagePtr image, int fg, gdIOCtx *out) +{ + int x, y, pos; + Wbmp *wbmp; + + /* create the WBMP */ + if((wbmp = createwbmp(gdImageSX(image), gdImageSY(image), WBMP_WHITE)) == NULL) { + gd_error("Could not create WBMP\n"); + return; + } + + /* fill up the WBMP structure */ + pos = 0; + for(y = 0; y < gdImageSY(image); y++) { + for(x = 0; x < gdImageSX(image); x++) { + if(gdImageGetPixel(image, x, y) == fg) { + wbmp->bitmap[pos] = WBMP_BLACK; + } + pos++; + } + } + + /* write the WBMP to a gd file descriptor */ + if(writewbmp(wbmp, &gd_putout, out)) { + gd_error("Could not save WBMP\n"); + } + + /* des submitted this bugfix: gdFree the memory. */ + freewbmp(wbmp); +} + +/* + Function: gdImageCreateFromWBMPCtx + + Reads in a WBMP image via a <gdIOCtx> struct. See + <gdImageCreateFromWBMP>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMPCtx(gdIOCtx *infile) +{ + Wbmp *wbmp; + gdImagePtr im = NULL; + int black, white; + int col, row, pos; + + if(readwbmp(&gd_getin, infile, &wbmp)) { + return (NULL); + } + + if(!(im = gdImageCreate(wbmp->width, wbmp->height))) { + freewbmp(wbmp); + return NULL; + } + + /* create the background color */ + white = gdImageColorAllocate(im, 255, 255, 255); + /* create foreground color */ + black = gdImageColorAllocate(im, 0, 0, 0); + + /* fill in image (in a wbmp 1 = white/ 0 = black) */ + pos = 0; + for(row = 0; row < wbmp->height; row++) { + for(col = 0; col < wbmp->width; col++) { + if(wbmp->bitmap[pos++] == WBMP_WHITE) { + gdImageSetPixel(im, col, row, white); + } else { + gdImageSetPixel(im, col, row, black); + } + } + } + + freewbmp(wbmp); + + return im; +} + + +/* + Function: gdImageCreateFromWBMP + + <gdImageCreateFromWBMP> is called to load images from WBMP format + files. Invoke <gdImageCreateFromWBMP> with an already opened + pointer to a file containing the desired + image. <gdImageCreateFromWBMP> returns a gdImagePtr to the new + image, or NULL if unable to load the image (most often because the + file is corrupt or does not contain a WBMP + image). <gdImageCreateFromWBMP> does not close the file. You can + inspect the sx and sy members of the image to determine its + size. The image must eventually be destroyed using + <gdImageDestroy>. + + Variants: + + <gdImageCreateFromWBMPPtr> creates an image from WBMP data (i.e. the + contents of a WBMP file) already in memory. + + <gdImageCreateFromWBMPCtx> reads in an image using the functions in + a <gdIOCtx> struct. + + Parameters: + + infile - The input FILE pointer + + Returns: + + A pointer to the new image or NULL if an error occurred. + + Example: + + > gdImagePtr im; + > FILE *in; + > in = fopen("mywbmp.wbmp", "rb"); + > im = gdImageCreateFromWBMP(in); + > fclose(in); + > // ... Use the image ... + > gdImageDestroy(im); + +*/ + +BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMP(FILE *inFile) +{ + gdImagePtr im; + gdIOCtx *in = gdNewFileCtx(inFile); + if (in == NULL) return NULL; + im = gdImageCreateFromWBMPCtx(in); + in->gd_free(in); + return im; +} + + +/* + Function: gdImageCreateFromWBMPPtr + + Parameters: + + size - size of WBMP data in bytes. + data - WBMP data (i.e. contents of a WBMP file). + + See <gdImageCreateFromWBMP>. +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromWBMPPtr(int size, void *data) +{ + gdImagePtr im; + gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); + if(!in) { + return 0; + } + im = gdImageCreateFromWBMPCtx(in); + in->gd_free(in); + return im; +} + +/* gdImageWBMP + */ +BGD_DECLARE(void) gdImageWBMP(gdImagePtr im, int fg, FILE *outFile) +{ + gdIOCtx *out = gdNewFileCtx(outFile); + if (out == NULL) return; + gdImageWBMPCtx(im, fg, out); + out->gd_free(out); +} + +/* gdImageWBMPPtr + */ +BGD_DECLARE(void *) gdImageWBMPPtr(gdImagePtr im, int *size, int fg) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx(2048, NULL); + if (out == NULL) return NULL; + gdImageWBMPCtx(im, fg, out); + rv = gdDPExtractData(out, size); + out->gd_free(out); + return rv; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_webp.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_webp.c new file mode 100644 index 00000000000..fae38610999 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_webp.c @@ -0,0 +1,211 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif /* HAVE_CONFIG_H */ + +#include <stdio.h> +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include "gd.h" +#include "gd_errors.h" + +#ifdef HAVE_LIBVPX +#include "webpimg.h" +#include "gdhelpers.h" + +extern void gd_YUV420toRGBA(uint8* Y, + uint8* U, + uint8* V, + gdImagePtr im); + +extern void gd_RGBAToYUV420(gdImagePtr im2, + uint8* Y, + uint8* U, + uint8* V); + +const char * gdWebpGetVersionString() +{ + return "not defined"; +} + +BGD_DECLARE(gdImagePtr) gdImageCreateFromWebp (FILE * inFile) +{ + gdImagePtr im; + gdIOCtx *in = gdNewFileCtx(inFile); + im = gdImageCreateFromWebpCtx(in); + in->gd_free(in); + + return im; +} + +BGD_DECLARE(gdImagePtr) gdImageCreateFromWebpPtr (int size, void *data) +{ + int width, height, ret; + unsigned char *Y = NULL; + unsigned char *U = NULL; + unsigned char *V = NULL; + gdImagePtr im; + + ret = WebPDecode(data, size, &Y, &U, &V, &width, &height); + if (ret != webp_success) { + if (Y) free(Y); + if (U) free(U); + if (V) free(V); + gd_error("WebP decode: fail to decode input data"); + return NULL; + } + im = gdImageCreateTrueColor(width, height); + if (!im) { + return NULL; + } + gd_YUV420toRGBA(Y, U, V, im); + return im; +} + +#define GD_WEBP_ALLOC_STEP (4*1024) + +BGD_DECLARE(gdImagePtr) gdImageCreateFromWebpCtx (gdIOCtx * infile) +{ + int width, height, ret; + unsigned char *filedata = NULL; + unsigned char *read, *temp; + unsigned char *Y = NULL; + unsigned char *U = NULL; + unsigned char *V = NULL; + size_t size = 0, n; + gdImagePtr im; + + do { + temp = gdRealloc(filedata, size+GD_WEBP_ALLOC_STEP); + if (temp) { + filedata = temp; + read = temp + size; + } else { + if (filedata) { + gdFree(filedata); + } + gd_error("WebP decode: realloc failed"); + return NULL; + } + + n = gdGetBuf(read, GD_WEBP_ALLOC_STEP, infile); + size += n; + } while (n>0); + + ret = WebPDecode(filedata, size, &Y, &U, &V, &width, &height); + gdFree(filedata); + if (ret != webp_success) { + if (Y) free(Y); + if (U) free(U); + if (V) free(V); + gd_error("WebP decode: fail to decode input data"); + return NULL; + } + im = gdImageCreateTrueColor(width, height); + gd_YUV420toRGBA(Y, U, V, im); + return im; +} + +BGD_DECLARE(void) gdImageWebpEx (gdImagePtr im, FILE * outFile, int quantization) +{ + gdIOCtx *out = gdNewFileCtx(outFile); + gdImageWebpCtx(im, out, quantization); + out->gd_free(out); +} + +BGD_DECLARE(void) gdImageWebp (gdImagePtr im, FILE * outFile) +{ + gdIOCtx *out = gdNewFileCtx(outFile); + gdImageWebpCtx(im, out, -1); + out->gd_free(out); +} + +BGD_DECLARE(void *) gdImageWebpPtr (gdImagePtr im, int *size) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx(2048, NULL); + gdImageWebpCtx(im, out, -1); + rv = gdDPExtractData(out, size); + out->gd_free(out); + + return rv; +} + +BGD_DECLARE(void *) gdImageWebpPtrEx (gdImagePtr im, int *size, int quantization) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx(2048, NULL); + gdImageWebpCtx(im, out, quantization); + rv = gdDPExtractData(out, size); + out->gd_free(out); + return rv; +} + +/* + * Maps normalized QP (quality) to VP8 QP + */ +int mapQualityToVP8QP(int quality) { +#define MIN_QUALITY 0 +#define MAX_QUALITY 100 +#define MIN_VP8QP 1 +#define MAX_VP8QP 63 + const float scale = MAX_VP8QP - MIN_VP8QP; + const float vp8qp = + scale * (MAX_QUALITY - quality) / (MAX_QUALITY - MIN_QUALITY) + MIN_VP8QP; + if (quality < MIN_QUALITY || quality > MAX_QUALITY) { + gd_error("Wrong quality value %d.", quality); + return -1; + } + + return (int)(vp8qp + 0.5); +} + +/* This routine is based in part on code from Dale Lutz (Safe Software Inc.) + * and in part on demo code from Chapter 15 of "PNG: The Definitive Guide" + * (http://www.cdrom.com/pub/png/pngbook.html). + */ +BGD_DECLARE(void) gdImageWebpCtx (gdImagePtr im, gdIOCtx * outfile, int quantization) +{ + int width = im->sx; + int height = im->sy; + + int yuv_width, yuv_height, yuv_nbytes, ret; + int vp8_quality; + unsigned char *Y = NULL, + *U = NULL, + *V = NULL; + unsigned char *filedata = NULL; + + /* Conversion to Y,U,V buffer */ + yuv_width = (width + 1) >> 1; + yuv_height = (height + 1) >> 1; + yuv_nbytes = width * height + 2 * yuv_width * yuv_height; + + if ((Y = (unsigned char *)gdCalloc(yuv_nbytes, sizeof(unsigned char))) == NULL) { + gd_error("gd-webp error: cannot allocate Y buffer"); + return; + } + vp8_quality = mapQualityToVP8QP(quantization); + + U = Y + width * height; + V = U + yuv_width * yuv_height; + gd_RGBAToYUV420(im, Y, U, V); + + /* Encode Y,U,V and write data to file */ + ret = WebPEncode(Y, U, V, width, height, width, yuv_width, yuv_height, yuv_width, + vp8_quality, &filedata, &yuv_nbytes, NULL); + gdFree(Y); + + if (ret != webp_success) { + if (filedata) { + free(filedata); + } + gd_error("gd-webp error: WebP Encoder failed"); + return; + } + + gdPutBuf (filedata, yuv_nbytes, outfile); + free(filedata); +} + +#endif /* HAVE_LIBVPX */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gd_xbm.c b/Build/source/libs/gd/libgd-2.1.1/src/gd_xbm.c new file mode 100644 index 00000000000..74d839b2667 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gd_xbm.c @@ -0,0 +1,253 @@ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <ctype.h> +#include <stdio.h> +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include <stdarg.h> +#include "gd.h" +#include "gd_errors.h" +#include "gdhelpers.h" + +#ifdef _MSC_VER +# define strcasecmp _stricmp +#endif + +#define MAX_XBM_LINE_SIZE 255 + + +/* + Function: gdImageCreateFromXbm + + <gdImageCreateFromXbm> is called to load images from X bitmap + format files. Invoke <gdImageCreateFromXbm> with an already opened + pointer to a file containing the desired + image. <gdImageCreateFromXbm> returns a <gdImagePtr> to the new + image, or NULL if unable to load the image (most often because the + file is corrupt or does not contain an X bitmap format + image). <gdImageCreateFromXbm> does not close the file. + + You can inspect the sx and sy members of the image to determine + its size. The image must eventually be destroyed using + <gdImageDestroy>. + + Parameters: + + fd - The input FILE pointer + + Returns: + + A pointer to the new image or NULL if an error occurred. + + Example: + + > gdImagePtr im; + > FILE *in; + > in = fopen("myxbm.xbm", "rb"); + > im = gdImageCreateFromXbm(in); + > fclose(in); + > // ... Use the image ... + > gdImageDestroy(im); +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromXbm(FILE * fd) +{ + char fline[MAX_XBM_LINE_SIZE]; + char iname[MAX_XBM_LINE_SIZE]; + char *type; + int value; + unsigned int width = 0, height = 0; + int fail = 0; + int max_bit = 0; + + gdImagePtr im; + int bytes = 0, i; + int bit, x = 0, y = 0; + int ch; + char h[8]; + unsigned int b; + + rewind(fd); + while (fgets(fline, MAX_XBM_LINE_SIZE, fd)) { + fline[MAX_XBM_LINE_SIZE-1] = '\0'; + if (strlen(fline) == MAX_XBM_LINE_SIZE-1) { + return 0; + } + if (sscanf(fline, "#define %s %d", iname, &value) == 2) { + if (!(type = strrchr(iname, '_'))) { + type = iname; + } else { + type++; + } + + if (!strcmp("width", type)) { + width = (unsigned int) value; + } + if (!strcmp("height", type)) { + height = (unsigned int) value; + } + } else { + if ( sscanf(fline, "static unsigned char %s = {", iname) == 1 + || sscanf(fline, "static char %s = {", iname) == 1) + { + max_bit = 128; + } else if (sscanf(fline, "static unsigned short %s = {", iname) == 1 + || sscanf(fline, "static short %s = {", iname) == 1) + { + max_bit = 32768; + } + if (max_bit) { + bytes = (width * height / 8) + 1; + if (!bytes) { + return 0; + } + if (!(type = strrchr(iname, '_'))) { + type = iname; + } else { + type++; + } + if (!strcmp("bits[]", type)) { + break; + } + } + } + } + if (!bytes || !max_bit) { + return 0; + } + + if(!(im = gdImageCreate(width, height))) { + return 0; + } + gdImageColorAllocate(im, 255, 255, 255); + gdImageColorAllocate(im, 0, 0, 0); + h[2] = '\0'; + h[4] = '\0'; + for (i = 0; i < bytes; i++) { + while (1) { + if ((ch=getc(fd)) == EOF) { + fail = 1; + break; + } + if (ch == 'x') { + break; + } + } + if (fail) { + break; + } + /* Get hex value */ + if ((ch=getc(fd)) == EOF) { + break; + } + h[0] = ch; + if ((ch=getc(fd)) == EOF) { + break; + } + h[1] = ch; + if (max_bit == 32768) { + if ((ch=getc(fd)) == EOF) { + break; + } + h[2] = ch; + if ((ch=getc(fd)) == EOF) { + break; + } + h[3] = ch; + } + sscanf(h, "%x", &b); + for (bit = 1; bit <= max_bit; bit = bit << 1) { + gdImageSetPixel(im, x++, y, (b & bit) ? 1 : 0); + if (x == im->sx) { + x = 0; + y++; + if (y == im->sy) { + return im; + } + break; + } + } + } + + gd_error("EOF before image was complete"); + gdImageDestroy(im); + return 0; +} + + +/* {{{ gdCtxPrintf */ +static void gdCtxPrintf(gdIOCtx * out, const char *format, ...) +{ + char buf[4096]; + int len; + va_list args; + + va_start(args, format); + len = vsnprintf(buf, sizeof(buf)-1, format, args); + va_end(args); + out->putBuf(out, buf, len); +} +/* }}} */ + +/* {{{ gdImageXbmCtx */ +BGD_DECLARE(void) gdImageXbmCtx(gdImagePtr image, char* file_name, int fg, gdIOCtx * out) +{ + int x, y, c, b, sx, sy, p; + char *name, *f; + size_t i, l; + + name = file_name; + if ((f = strrchr(name, '/')) != NULL) name = f+1; + if ((f = strrchr(name, '\\')) != NULL) name = f+1; + name = strdup(name); + if ((f = strrchr(name, '.')) != NULL && !strcasecmp(f, ".XBM")) *f = '\0'; + if ((l = strlen(name)) == 0) { + free(name); + name = strdup("image"); + } else { + for (i=0; i<l; i++) { + /* only in C-locale isalnum() would work */ + if (!isupper(name[i]) && !islower(name[i]) && !isdigit(name[i])) { + name[i] = '_'; + } + } + } + + gdCtxPrintf(out, "#define %s_width %d\n", name, gdImageSX(image)); + gdCtxPrintf(out, "#define %s_height %d\n", name, gdImageSY(image)); + gdCtxPrintf(out, "static unsigned char %s_bits[] = {\n ", name); + + free(name); + + b = 1; + p = 0; + c = 0; + sx = gdImageSX(image); + sy = gdImageSY(image); + for (y = 0; y < sy; y++) { + for (x = 0; x < sx; x++) { + if (gdImageGetPixel(image, x, y) == fg) { + c |= b; + } + if ((b == 128) || (x == sx && y == sy)) { + b = 1; + if (p) { + gdCtxPrintf(out, ", "); + if (!(p%12)) { + gdCtxPrintf(out, "\n "); + p = 12; + } + } + p++; + gdCtxPrintf(out, "0x%02X", c); + c = 0; + } else { + b <<= 1; + } + } + } + gdCtxPrintf(out, "};\n"); +} +/* }}} */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdcache.c b/Build/source/libs/gd/libgd-2.1.1/src/gdcache.c new file mode 100644 index 00000000000..b264d6ef859 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdcache.c @@ -0,0 +1,224 @@ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "gd.h" +#include "gdhelpers.h" + +#ifdef HAVE_LIBTTF +# define NEED_CACHE 1 +#else +#ifdef HAVE_LIBFREETYPE +# define NEED_CACHE 1 +#endif +#endif + +#ifdef NEED_CACHE + +/* + * gdcache.c + * + * Caches of pointers to user structs in which the least-recently-used + * element is replaced in the event of a cache miss after the cache has + * reached a given size. + * + * John Ellson (ellson@graphviz.org) Oct 31, 1997 + * + * Test this with: + * gcc -o gdcache -g -Wall -DTEST gdcache.c + * + * The cache is implemented by a singly-linked list of elements + * each containing a pointer to a user struct that is being managed by + * the cache. + * + * The head structure has a pointer to the most-recently-used + * element, and elements are moved to this position in the list each + * time they are used. The head also contains pointers to three + * user defined functions: + * - a function to test if a cached userdata matches some keydata + * - a function to provide a new userdata struct to the cache + * if there has been a cache miss. + * - a function to release a userdata struct when it is + * no longer being managed by the cache + * + * In the event of a cache miss the cache is allowed to grow up to + * a specified maximum size. After the maximum size is reached then + * the least-recently-used element is discarded to make room for the + * new. The most-recently-returned value is always left at the + * beginning of the list after retrieval. + * + * In the current implementation the cache is traversed by a linear + * search from most-recent to least-recent. This linear search + * probably limits the usefulness of this implementation to cache + * sizes of a few tens of elements. + */ + +#include "gdcache.h" + +/*********************************************************/ +/* implementation */ +/*********************************************************/ + +/* create a new cache */ +gdCache_head_t *gdCacheCreate(int size, + gdCacheTestFn_t gdCacheTest, + gdCacheFetchFn_t gdCacheFetch, + gdCacheReleaseFn_t gdCacheRelease) +{ + gdCache_head_t *head; + + head = (gdCache_head_t *)gdMalloc(sizeof(gdCache_head_t)); + if(!head) { + return NULL; + } + + head->mru = NULL; + head->size = size; + head->gdCacheTest = gdCacheTest; + head->gdCacheFetch = gdCacheFetch; + head->gdCacheRelease = gdCacheRelease; + + return head; +} + +void gdCacheDelete(gdCache_head_t *head) +{ + gdCache_element_t *elem, *prev; + + elem = head->mru; + while(elem) { + (*(head->gdCacheRelease))(elem->userdata); + prev = elem; + elem = elem->next; + gdFree((char *)prev); + } + + gdFree((char *)head); +} + +void * gdCacheGet(gdCache_head_t *head, void *keydata) +{ + int i = 0; + gdCache_element_t *elem, *prev = NULL, *prevprev = NULL; + void *userdata; + + elem = head->mru; + while(elem) { + if((*(head->gdCacheTest))(elem->userdata, keydata)) { + if(i) { + /* if not already most-recently-used */ + /* relink to top of list */ + prev->next = elem->next; + elem->next = head->mru; + head->mru = elem; + } + + return elem->userdata; + } + + prevprev = prev; + prev = elem; + elem = elem->next; + i++; + } + + userdata = (*(head->gdCacheFetch))(&(head->error), keydata); + if(!userdata) { + /* if there was an error in the fetch then don't cache */ + return NULL; + } + + if(i < head->size) { + /* cache still growing - add new elem */ + elem = (gdCache_element_t *)gdMalloc(sizeof(gdCache_element_t)); + if(!elem) { + (*(head->gdCacheRelease)) (userdata); + return NULL; + } + } else { + /* cache full - replace least-recently-used */ + /* preveprev becomes new end of list */ + prevprev->next = NULL; + elem = prev; + (*(head->gdCacheRelease))(elem->userdata); + } + + /* relink to top of list */ + elem->next = head->mru; + head->mru = elem; + elem->userdata = userdata; + + return userdata; +} + +/*********************************************************/ +/* test stub */ +/*********************************************************/ + +#ifdef TEST + +#include <stdio.h> + +typedef struct { + int key; + int value; +} +key_value_t; + +static int cacheTest(void *map, void *key) +{ + return (((key_value_t *)map)->key == *(int *)key); +} + +static void *cacheFetch(char **error, void *key) +{ + key_value_t *map; + + map = (key_value_t *)gdMalloc(sizeof(key_value_t)); + if (!map) { + *error = "gdMalloc failed"; + return NULL; + } + map->key = *(int *)key; + map->value = 3; + + *error = NULL; + + return (void *)map; +} + +static void cacheRelease(void *map) +{ + gdFree((char *)map); +} + +int main(char *argv[], int argc) +{ + gdCache_head_t *cacheTable; + int elem, key; + + cacheTable = gdCacheCreate(3, cacheTest, cacheFetch, cacheRelease); + if(!cacheTable) { + exit(1); + } + + key = 20; + elem = *(int *)gdCacheGet(cacheTable, &key); + key = 30; + elem = *(int *)gdCacheGet(cacheTable, &key); + key = 40; + elem = *(int *)gdCacheGet(cacheTable, &key); + key = 50; + elem = *(int *)gdCacheGet(cacheTable, &key); + key = 30; + elem = *(int *)gdCacheGet(cacheTable, &key); + key = 30; + elem = *(int *)gdCacheGet(cacheTable, &key); + + gdCacheDelete(cacheTable); + + return 0; +} + +#endif /* TEST */ +#endif /* NEED_CACHE */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdcache.h b/Build/source/libs/gd/libgd-2.1.1/src/gdcache.h new file mode 100644 index 00000000000..bf451dc6cc3 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdcache.h @@ -0,0 +1,88 @@ +#ifdef __cplusplus +extern "C" { +#endif + + /* + * gdcache.h + * + * Caches of pointers to user structs in which the least-recently-used + * element is replaced in the event of a cache miss after the cache has + * reached a given size. + * + * John Ellson (ellson@graphviz.org) Oct 31, 1997 + * + * Test this with: + * gcc -o gdcache -g -Wall -DTEST gdcache.c + * + * The cache is implemented by a singly-linked list of elements + * each containing a pointer to a user struct that is being managed by + * the cache. + * + * The head structure has a pointer to the most-recently-used + * element, and elements are moved to this position in the list each + * time they are used. The head also contains pointers to three + * user defined functions: + * - a function to test if a cached userdata matches some keydata + * - a function to provide a new userdata struct to the cache + * if there has been a cache miss. + * - a function to release a userdata struct when it is + * no longer being managed by the cache + * + * In the event of a cache miss the cache is allowed to grow up to + * a specified maximum size. After the maximum size is reached then + * the least-recently-used element is discarded to make room for the + * new. The most-recently-returned value is always left at the + * beginning of the list after retrieval. + * + * In the current implementation the cache is traversed by a linear + * search from most-recent to least-recent. This linear search + * probably limits the usefulness of this implementation to cache + * sizes of a few tens of elements. + */ + + /*********************************************************/ + /* header */ + /*********************************************************/ + +#include <stdlib.h> +#ifndef NULL +# define NULL (void *)0 +#endif + + /* user defined function templates */ + typedef int (*gdCacheTestFn_t)(void *userdata, void *keydata); + typedef void *(*gdCacheFetchFn_t)(char **error, void *keydata); + typedef void (*gdCacheReleaseFn_t)(void *userdata); + + /* element structure */ + typedef struct gdCache_element_s gdCache_element_t; + struct gdCache_element_s { + gdCache_element_t *next; + void *userdata; + }; + + /* head structure */ + typedef struct gdCache_head_s gdCache_head_t; + struct gdCache_head_s { + gdCache_element_t *mru; + int size; + char *error; + gdCacheTestFn_t gdCacheTest; + gdCacheFetchFn_t gdCacheFetch; + gdCacheReleaseFn_t gdCacheRelease; + }; + + /* function templates */ + gdCache_head_t *gdCacheCreate(int size, + gdCacheTestFn_t gdCacheTest, + gdCacheFetchFn_t gdCacheFetch, + gdCacheReleaseFn_t gdCacheRelease + ); + + void gdCacheDelete(gdCache_head_t *head); + + void *gdCacheGet(gdCache_head_t *head, void *keydata); + +#ifdef __cplusplus +} +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdcmpgif.c b/Build/source/libs/gd/libgd-2.1.1/src/gdcmpgif.c new file mode 100644 index 00000000000..737f7ba90b8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdcmpgif.c @@ -0,0 +1,93 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#ifndef _WIN32 +#include <unistd.h> /* For unlink function */ +#endif + +#include "gd.h" + +/* A short program which converts a .png file into a .gd file, for + your convenience in creating images on the fly from a + basis image that must be loaded quickly. The .gd format + is not intended to be a general-purpose format. */ + +void CompareImages(char *msg, gdImagePtr im1, gdImagePtr im2); + + +int main(int argc, char **argv) +{ + gdImagePtr im1, im2; + FILE *in; + + if (argc != 3) { + fprintf(stderr, "Usage: gdcmpgif filename.gif filename.gif\n"); + exit(1); + } + in = fopen(argv[1], "rb"); + if (!in) { + fprintf(stderr, "Input file does not exist!\n"); + exit(1); + } + im1 = gdImageCreateFromGif(in); + fclose(in); + + if (!im1) { + fprintf(stderr, "Input is not in GIF format!\n"); + exit(1); + } + + in = fopen(argv[2], "rb"); + if (!in) { + fprintf(stderr, "Input file 2 does not exist!\n"); + exit(1); + } + im2 = gdImageCreateFromGif(in); + fclose(in); + + if (!im2) { + fprintf(stderr, "Input 2 is not in GIF format!\n"); + exit(1); + } + + CompareImages("gdcmpgif", im1, im2); + + gdImageDestroy(im1); + gdImageDestroy(im2); + + return 0; +} + +void CompareImages(char *msg, gdImagePtr im1, gdImagePtr im2) +{ + int cmpRes; + + cmpRes = gdImageCompare(im1, im2); + + if (cmpRes & GD_CMP_IMAGE) { + printf("%%%s: ERROR images differ: BAD\n",msg); + } else if (cmpRes != 0) { + printf("%%%s: WARNING images differ: WARNING - Probably OK\n",msg); + } else { + printf("%%%s: OK\n",msg); + return; + } + + if (cmpRes & (GD_CMP_SIZE_X + GD_CMP_SIZE_Y)) { + printf("-%s: INFO image sizes differ\n",msg); + } + + if (cmpRes & GD_CMP_NUM_COLORS) { + printf("-%s: INFO number of palette entries differ %d Vs. %d\n",msg, + im1->colorsTotal, im2->colorsTotal); + } + + if (cmpRes & GD_CMP_COLOR) { + printf("-%s: INFO actual colours of pixels differ\n",msg); + } +} + + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gddemo.c b/Build/source/libs/gd/libgd-2.1.1/src/gddemo.c new file mode 100644 index 00000000000..28afd3c1d12 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gddemo.c @@ -0,0 +1,188 @@ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <math.h> +#include <stdlib.h> +#include "gd.h" +#include "gdfontt.h" +#include "gdfonts.h" +#include "gdfontmb.h" +#include "gdfontl.h" +#include "gdfontg.h" + +int +main (void) +{ +#ifdef HAVE_LIBPNG + /* Input and output files */ + FILE *in; + FILE *out; + + /* Input and output images */ + gdImagePtr im_in = 0, im_out = 0; + + /* Brush image */ + gdImagePtr brush; + + /* Color indexes */ + int white; + int blue; + int red; + int green; + + /* Points for polygon */ + gdPoint points[3]; + int i; + + /* gd fonts for font test */ + gdFontPtr fonts[5]; + int y; + + /* Create output image, in true color. */ + im_out = gdImageCreateTrueColor (256 + 384, 384); + /* 2.0.2: first color allocated would automatically be background in a + palette based image. Since this is a truecolor image, with an + automatic background of black, we must fill it explicitly. */ + white = gdImageColorAllocate (im_out, 255, 255, 255); + gdImageFilledRectangle (im_out, 0, 0, gdImageSX (im_out), + gdImageSY (im_out), white); + + /* Set transparent color. */ + gdImageColorTransparent (im_out, white); + + /* Try to load demoin.png and paste part of it into the + output image. */ + in = fopen ("demoin.png", "rb"); + if (!in) { + fprintf(stderr, "Can't load source image; this demo\n"); + fprintf(stderr, "is much more impressive if demoin.png\n"); + fprintf(stderr, "is available.\n"); + im_in = 0; + } else { + int a; + im_in = gdImageCreateFromPng (in); + fclose (in); + /* Now copy, and magnify as we do so */ + gdImageCopyResampled (im_out, im_in, 32, 32, 0, 0, 192, 192, 255, 255); + /* Now display variously rotated space shuttles in a circle of our own */ + for (a = 0; (a < 360); a += 45) { + int cx = cos (a * .0174532925) * 128; + int cy = -sin (a * .0174532925) * 128; + gdImageCopyRotated (im_out, im_in, + 256 + 192 + cx, 192 + cy, + 0, 0, gdImageSX (im_in), gdImageSY (im_in), a); + } + } + red = gdImageColorAllocate (im_out, 255, 0, 0); + green = gdImageColorAllocate (im_out, 0, 255, 0); + blue = gdImageColorAllocate (im_out, 0, 0, 255); + /* Fat Rectangle */ + gdImageSetThickness (im_out, 4); + gdImageLine (im_out, 16, 16, 240, 16, green); + gdImageLine (im_out, 240, 16, 240, 240, green); + gdImageLine (im_out, 240, 240, 16, 240, green); + gdImageLine (im_out, 16, 240, 16, 16, green); + gdImageSetThickness (im_out, 1); + /* Circle */ + gdImageArc (im_out, 128, 128, 60, 20, 0, 720, blue); + /* Arc */ + gdImageArc (im_out, 128, 128, 40, 40, 90, 270, blue); + /* Flood fill: doesn't do much on a continuously + variable tone jpeg original. */ + gdImageFill (im_out, 8, 8, blue); + /* Polygon */ + points[0].x = 64; + points[0].y = 0; + points[1].x = 0; + points[1].y = 128; + points[2].x = 128; + points[2].y = 128; + gdImageFilledPolygon (im_out, points, 3, green); + /* 2.0.12: Antialiased Polygon */ + gdImageSetAntiAliased (im_out, green); + for (i = 0; (i < 3); i++) { + points[i].x += 128; + } + gdImageFilledPolygon (im_out, points, 3, gdAntiAliased); + /* Brush. A fairly wild example also involving a line style! */ + if (im_in) { + int style[8]; + brush = gdImageCreateTrueColor (16, 16); + gdImageCopyResized (brush, im_in, + 0, 0, 0, 0, + gdImageSX (brush), gdImageSY (brush), + gdImageSX (im_in), gdImageSY (im_in)); + gdImageSetBrush (im_out, brush); + /* With a style, so they won't overprint each other. + Normally, they would, yielding a fat-brush effect. */ + style[0] = 0; + style[1] = 0; + style[2] = 0; + style[3] = 0; + style[4] = 0; + style[5] = 0; + style[6] = 0; + style[7] = 1; + gdImageSetStyle (im_out, style, 8); + /* Draw the styled, brushed line */ + gdImageLine (im_out, 0, 255, 255, 0, gdStyledBrushed); + } + /* Text (non-truetype; see gdtestft for a freetype demo) */ + fonts[0] = gdFontGetTiny (); + fonts[1] = gdFontGetSmall (); + fonts[2] = gdFontGetMediumBold (); + fonts[3] = gdFontGetLarge (); + fonts[4] = gdFontGetGiant (); + y = 0; + for (i = 0; (i <= 4); i++) { + gdImageString (im_out, fonts[i], 32, 32 + y, (unsigned char *) "hi", + red); + y += fonts[i]->h; + } + y = 0; + for (i = 0; (i <= 4); i++) { + gdImageStringUp (im_out, fonts[i], 64 + y, 64, + (unsigned char *) "hi", red); + y += fonts[i]->h; + } + /* Random antialiased lines; coordinates all over the image, + but the output will respect a small clipping rectangle */ + gdImageSetClip (im_out, 0, gdImageSY (im_out) - 100, + 100, gdImageSY (im_out)); + /* Fixed seed for reproducibility of results */ + srand (100); + for (i = 0; (i < 100); i++) { + int x1 = rand () % gdImageSX (im_out); + int y1 = rand () % gdImageSY (im_out); + int x2 = rand () % gdImageSX (im_out); + int y2 = rand () % gdImageSY (im_out); + gdImageSetAntiAliased (im_out, white); + gdImageLine (im_out, x1, y1, x2, y2, gdAntiAliased); + } + /* Make output image interlaced (progressive, in the case of JPEG) */ + gdImageInterlace (im_out, 1); + out = fopen ("demoout.png", "wb"); + /* Write PNG */ + gdImagePng (im_out, out); + fclose (out); + out = fopen ("demoout.gif", "wb"); + /* Write GIF (2.0.28) */ + gdImageGif (im_out, out); + fclose (out); + /* 2.0.12: also write a paletteized png comparable to the gif */ + out = fopen ("demooutp.png", "wb"); + gdImageTrueColorToPalette (im_out, 0, 256); + gdImagePng (im_out, out); + fclose (out); + gdImageDestroy (im_out); + if (im_in) { + gdImageDestroy (im_in); + } +#else + fprintf(stderr, "No PNG library support.\n"); +#endif /* HAVE_LIBPNG */ + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdfontg.c b/Build/source/libs/gd/libgd-2.1.1/src/gdfontg.c new file mode 100644 index 00000000000..37178602695 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdfontg.c @@ -0,0 +1,4390 @@ + + +/* + This is a header file for gd font, generated using + bdftogd version 0.51 by Jan Pazdziora, adelton@fi.muni.cz + from bdf font + -Misc-Fixed-Bold-R-Normal-Sans-15-140-75-75-C-90-ISO8859-2 + at Mon Jan 26 14:45:58 1998. + The original bdf was holding following copyright: + "Libor Skarvada, libor@informatics.muni.cz" + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gdfontg.h" + +char gdFontGiantData[] = { + /* Char 0 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 1 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 2 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 1, 0, 1, 0, + + /* Char 3 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 4 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 5 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 6 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 7 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 8 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 9 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 10 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 11 */ + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 12 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + + /* Char 13 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + + /* Char 14 */ + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 15 */ + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + + /* Char 16 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 17 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 18 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 19 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 20 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 21 */ + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + + /* Char 22 */ + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + + /* Char 23 */ + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 24 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + + /* Char 25 */ + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + + /* Char 26 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 27 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 28 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 29 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 30 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, 0, + 1, 0, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 31 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 32 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 33 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 34 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 35 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 36 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 37 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 38 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 1, 0, + 1, 1, 0, 0, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 39 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 40 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 41 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 42 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 43 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 44 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 45 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 46 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 47 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 48 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 49 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 50 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 51 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 52 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 53 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 54 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 55 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 56 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 57 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 58 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 59 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 60 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 61 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 62 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 63 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 64 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 65 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 66 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 67 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 68 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 69 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 70 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 71 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 72 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 73 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 74 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 75 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 76 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 77 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 0, 0, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 78 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 79 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 80 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 81 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 82 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 83 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 84 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 85 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 86 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 87 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 0, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 88 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 89 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 90 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 91 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 92 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 93 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 94 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 95 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 96 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 97 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 98 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 99 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 100 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 101 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 102 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 103 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + + /* Char 104 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 105 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 106 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, 0, + + /* Char 107 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 108 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 109 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 1, 0, 1, 1, 0, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 110 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 111 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 112 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + + /* Char 113 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + + /* Char 114 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 115 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 116 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 117 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 118 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 119 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 120 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 121 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 1, 0, + 1, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + + /* Char 122 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 123 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 124 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 125 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 126 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 127 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 128 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 129 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 130 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 131 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 132 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 133 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 134 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 135 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 136 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 137 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 138 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 139 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 140 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 141 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 142 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 143 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 144 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 145 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 146 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 147 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 148 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 149 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 150 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 151 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 152 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 153 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 154 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 155 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 156 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 157 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 158 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 159 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 160 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 161 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + + /* Char 162 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 163 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 164 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 165 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 166 */ + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 167 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 168 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 169 */ + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 170 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, 0, + + /* Char 171 */ + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 172 */ + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 173 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 174 */ + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 175 */ + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 176 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 177 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 1, + + /* Char 178 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 1, 0, 0, + + /* Char 179 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 180 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 181 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 182 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 183 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 184 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + + /* Char 185 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 186 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, 0, + + /* Char 187 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 188 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 189 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 190 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 191 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 192 */ + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 193 */ + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 194 */ + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 195 */ + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 196 */ + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 197 */ + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 198 */ + 0, 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 199 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + + /* Char 200 */ + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 201 */ + 0, 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 202 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 1, 0, + + /* Char 203 */ + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 204 */ + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 205 */ + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 206 */ + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 207 */ + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 208 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 209 */ + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 210 */ + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 211 */ + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 212 */ + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 213 */ + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 214 */ + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 215 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 216 */ + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 217 */ + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 218 */ + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 219 */ + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 220 */ + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 221 */ + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 222 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + + /* Char 223 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 224 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 225 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 226 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 227 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 228 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 229 */ + 0, 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 230 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 231 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + + /* Char 232 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 233 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 234 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 1, 0, + + /* Char 235 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 236 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 237 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 238 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 239 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 1, 1, + 0, 0, 0, 0, 0, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 240 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 241 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 242 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 243 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 244 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 245 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 246 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 247 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 248 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 249 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 250 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 251 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 252 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 253 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 1, 0, + 1, 0, 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, 0, + + /* Char 254 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, 0, + + /* Char 255 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + + +}; + +gdFont gdFontGiantRep = { + 256, + 0, + 9, + 15, + gdFontGiantData +}; + +BGD_EXPORT_DATA_PROT gdFontPtr gdFontGiant = &gdFontGiantRep; + +BGD_DECLARE(gdFontPtr) gdFontGetGiant (void) +{ + return gdFontGiant; +} + +/* This file has not been truncated. */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdfontg.h b/Build/source/libs/gd/libgd-2.1.1/src/gdfontg.h new file mode 100644 index 00000000000..5d85812cf42 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdfontg.h @@ -0,0 +1,28 @@ +#ifndef _GDFONTG_H_ +#define _GDFONTG_H_ 1 + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* + This is a header file for gd font, generated using + bdftogd version 0.51 by Jan Pazdziora, adelton@fi.muni.cz + from bdf font + -Misc-Fixed-Bold-R-Normal-Sans-15-140-75-75-C-90-ISO8859-2 + at Mon Jan 26 14:45:58 1998. + The original bdf was holding following copyright: + "Libor Skarvada, libor@informatics.muni.cz" + */ + +#include "gd.h" + +extern BGD_EXPORT_DATA_PROT gdFontPtr gdFontGiant; +BGD_DECLARE(gdFontPtr) gdFontGetGiant(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdfontl.c b/Build/source/libs/gd/libgd-2.1.1/src/gdfontl.c new file mode 100644 index 00000000000..a987407aeca --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdfontl.c @@ -0,0 +1,4648 @@ + + +/* + This is a header file for gd font, generated using + bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz + from bdf font + -misc-fixed-medium-r-normal--16-140-75-75-c-80-iso8859-2 + at Tue Jan 6 19:39:27 1998. + + The original bdf was holding following copyright: + "Libor Skarvada, libor@informatics.muni.cz" + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gdfontl.h" + +char gdFontLargeData[] = { + /* Char 0 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 1 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 2 */ + 1, 0, 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, 0, 1, + + /* Char 3 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 4 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 5 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 6 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 7 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 8 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 9 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 0, 0, 0, + 1, 0, 1, 0, 1, 0, 0, 0, + 1, 0, 0, 1, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 10 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 11 */ + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 12 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + + /* Char 13 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 1, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + + /* Char 14 */ + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 15 */ + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + + /* Char 16 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 17 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 18 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 19 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 20 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 21 */ + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 1, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + + /* Char 22 */ + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + + /* Char 23 */ + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 24 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + + /* Char 25 */ + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + + /* Char 26 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 27 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 28 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 1, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 29 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 30 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 1, 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 31 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 32 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 33 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 34 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 35 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 36 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 37 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 1, 0, 0, + 1, 0, 0, 1, 0, 1, 0, 0, + 0, 1, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 1, 0, 0, + 0, 1, 0, 1, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 38 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 39 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 40 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 41 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 42 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 1, 0, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 43 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 44 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 45 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 46 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 47 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 48 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 49 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 50 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 51 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 52 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 53 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 54 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 55 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 56 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 57 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 58 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 59 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 60 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 61 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 62 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 63 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 64 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 65 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 66 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 67 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 68 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 69 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 70 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 71 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 72 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 73 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 74 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 75 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 76 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 77 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 1, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 78 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 1, 0, 1, 0, + 0, 1, 0, 0, 1, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 79 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 80 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 81 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 1, 0, 1, 0, + 0, 1, 1, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 82 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 83 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 84 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 85 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 86 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 87 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 88 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 89 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 90 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 91 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 92 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 93 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 94 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 95 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 96 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 97 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 98 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 99 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 100 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 101 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 102 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 103 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + + /* Char 104 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 105 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 106 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + + /* Char 107 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 108 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 109 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 110 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 111 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 112 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + + /* Char 113 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + + /* Char 114 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 115 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 116 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 117 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 118 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 119 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 120 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 121 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + + /* Char 122 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 123 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 124 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 125 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 126 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 127 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 128 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 129 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 130 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 131 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 132 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 133 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 134 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 135 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 136 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 137 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 138 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 139 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 140 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 141 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 142 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 143 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 144 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 145 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 146 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 147 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 148 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 149 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 150 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 151 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 152 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 153 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 154 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 155 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 156 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 157 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 158 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 159 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 160 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 161 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, + + /* Char 162 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 163 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 164 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 165 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 166 */ + 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 167 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 168 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 169 */ + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 170 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + + /* Char 171 */ + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 172 */ + 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 173 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 174 */ + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 175 */ + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 176 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 177 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, + + /* Char 178 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 1, 0, + + /* Char 179 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 180 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 181 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 182 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 183 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 184 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + + /* Char 185 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 186 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + + /* Char 187 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 188 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 189 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 190 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 191 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 192 */ + 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 193 */ + 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 194 */ + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 195 */ + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 196 */ + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 197 */ + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 198 */ + 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 199 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + + /* Char 200 */ + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 201 */ + 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 202 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, + + /* Char 203 */ + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 204 */ + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 205 */ + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 206 */ + 0, 0, 1, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 207 */ + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 208 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 209 */ + 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 1, 0, 1, 0, + 0, 1, 0, 0, 1, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 210 */ + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 1, 0, 1, 0, + 0, 1, 0, 0, 1, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 211 */ + 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 212 */ + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 213 */ + 0, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 214 */ + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 215 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 216 */ + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 217 */ + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 218 */ + 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 219 */ + 0, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 220 */ + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 221 */ + 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 222 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + + /* Char 223 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 1, 1, 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 224 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 225 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 226 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 227 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 228 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 229 */ + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 230 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 231 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + + /* Char 232 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 233 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 234 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + + /* Char 235 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 236 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 237 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 238 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 239 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 1, 0, 1, + 0, 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 240 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 241 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 242 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 243 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 244 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 245 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 1, + 0, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 246 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 247 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 248 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 249 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 250 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 251 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 1, + 0, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 252 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + /* Char 253 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, 0, + + /* Char 254 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + + /* Char 255 */ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + +}; + +gdFont gdFontLargeRep = { + 256, + 0, + 8, + 16, + gdFontLargeData +}; + +BGD_EXPORT_DATA_PROT gdFontPtr gdFontLarge = &gdFontLargeRep; + +BGD_DECLARE(gdFontPtr) +gdFontGetLarge (void) +{ + return gdFontLarge; +} + +/* This file has not been truncated. */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdfontl.h b/Build/source/libs/gd/libgd-2.1.1/src/gdfontl.h new file mode 100644 index 00000000000..2fc91ca6bff --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdfontl.h @@ -0,0 +1,29 @@ +#ifndef _GDFONTL_H_ +#define _GDFONTL_H_ 1 + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* + This is a header file for gd font, generated using + bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz + from bdf font + -misc-fixed-medium-r-normal--16-140-75-75-c-80-iso8859-2 + at Tue Jan 6 19:39:27 1998. + + The original bdf was holding following copyright: + "Libor Skarvada, libor@informatics.muni.cz" + */ + +#include "gd.h" + +extern BGD_EXPORT_DATA_PROT gdFontPtr gdFontLarge; +BGD_DECLARE(gdFontPtr) gdFontGetLarge(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdfontmb.c b/Build/source/libs/gd/libgd-2.1.1/src/gdfontmb.c new file mode 100644 index 00000000000..349b2dbde28 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdfontmb.c @@ -0,0 +1,3878 @@ + + +/* + This is a header file for gd font, generated using + bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz + from bdf font + -misc-fixed-bold-r-normal-sans-13-94-100-100-c-70-iso8859-2 + at Thu Jan 8 13:54:57 1998. + No copyright info was found in the original bdf. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gdfontmb.h" + +char gdFontMediumBoldData[] = { + /* Char 0 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 1 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 2 */ + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 3 */ + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 4 */ + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 5 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 1, 0, + 0, 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 6 */ + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 7 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 8 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 9 */ + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 10 */ + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 0, 0, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 11 */ + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 12 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + + /* Char 13 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, + 0, 0, 1, 1, 1, 1, 1, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + + /* Char 14 */ + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, + 0, 0, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 15 */ + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + + /* Char 16 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 17 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 18 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 19 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 20 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 21 */ + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 1, 1, + 0, 0, 1, 1, 1, 1, 1, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + + /* Char 22 */ + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + + /* Char 23 */ + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 24 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + + /* Char 25 */ + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + + /* Char 26 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 27 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 28 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 1, 0, + 1, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 29 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 30 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 1, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 31 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 32 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 33 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 34 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 35 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 1, 0, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 0, 1, 0, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 36 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 0, 1, 1, 0, 1, 0, + 1, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 1, 0, + 1, 0, 1, 1, 0, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 37 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 1, 0, + 1, 0, 1, 0, 1, 1, 0, + 1, 1, 1, 0, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 1, 0, + 1, 1, 0, 1, 0, 1, 0, + 1, 0, 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 38 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 1, 0, 1, 0, + 1, 1, 0, 1, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 39 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 40 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 41 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 42 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 43 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 44 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 45 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 46 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 47 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 48 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 1, 0, + 1, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 49 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 1, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 50 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 51 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 52 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 0, 1, 1, 1, 1, 0, + 0, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 53 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 54 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 55 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 56 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 57 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 58 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 59 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 60 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 61 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 62 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 63 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 64 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 1, 0, + 1, 0, 1, 1, 1, 1, 0, + 1, 0, 1, 0, 1, 1, 0, + 1, 0, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 65 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 66 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 67 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 68 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 69 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 70 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 71 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 72 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 73 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 74 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 75 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 76 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 77 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 78 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 0, 1, 1, 0, + 1, 1, 1, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 1, 1, 1, 0, + 1, 1, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 79 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 80 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 81 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 82 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 83 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 84 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 85 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 86 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 87 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 88 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 89 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 90 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 91 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 92 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 93 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 94 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 95 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 96 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 97 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 98 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 99 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 100 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 101 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 102 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 103 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + + /* Char 104 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 105 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 106 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + + /* Char 107 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 108 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 109 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 110 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 111 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 112 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + + /* Char 113 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + + /* Char 114 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 115 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 116 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 117 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 118 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 119 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 120 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 121 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + + /* Char 122 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 123 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 124 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 125 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 126 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 127 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 128 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 129 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 130 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 131 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 132 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 133 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 134 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 135 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 136 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 137 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 138 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 139 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 140 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 141 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 142 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 143 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 144 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 145 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 146 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 147 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 148 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 149 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 150 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 151 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 152 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 153 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 154 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 155 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 156 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 157 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 158 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 159 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 160 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 161 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + + /* Char 162 */ + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 163 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 164 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 1, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 1, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 165 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 166 */ + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 167 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 168 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 169 */ + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 170 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + + /* Char 171 */ + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 172 */ + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 173 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 174 */ + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 175 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 176 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 177 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + + /* Char 178 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + + /* Char 179 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 1, 0, + 0, 0, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 1, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 180 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 181 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 1, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 182 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 183 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 184 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + + /* Char 185 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 186 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + + /* Char 187 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 188 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 189 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 190 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 191 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 192 */ + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 193 */ + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 194 */ + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 195 */ + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 196 */ + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 197 */ + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 198 */ + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 199 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + + /* Char 200 */ + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 201 */ + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 202 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + + /* Char 203 */ + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 204 */ + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 205 */ + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 206 */ + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 207 */ + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 208 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 1, 0, + 1, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 209 */ + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 0, 1, 1, 0, + 1, 1, 1, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 1, 1, 1, 0, + 1, 1, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 210 */ + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 0, 1, 1, 0, + 1, 1, 1, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 1, 1, 1, 0, + 1, 1, 0, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 211 */ + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 212 */ + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 213 */ + 0, 1, 1, 0, 0, 1, 1, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 214 */ + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 215 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 216 */ + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 217 */ + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 218 */ + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 219 */ + 0, 1, 1, 0, 0, 1, 1, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 220 */ + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 221 */ + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 222 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + + /* Char 223 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 0, 1, 1, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 224 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 225 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 226 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 227 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 228 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 229 */ + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 230 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 231 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + + /* Char 232 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 233 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 234 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, 0, + + /* Char 235 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 236 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 237 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 238 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 239 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, + 0, 0, 0, 1, 1, 0, 1, + 0, 0, 0, 1, 1, 1, 0, + 0, 0, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 1, 1, 0, 1, 1, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 240 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 1, 1, + 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 241 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 242 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 243 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 244 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 245 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 246 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 247 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 248 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 249 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 250 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 251 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 1, 1, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 252 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + /* Char 253 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 1, 1, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 1, 0, + 0, 1, 1, 1, 1, 0, 0, + + /* Char 254 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 1, 0, + 0, 0, 1, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, 0, + + /* Char 255 */ + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + +}; + +gdFont gdFontMediumBoldRep = { + 256, + 0, + 7, + 13, + gdFontMediumBoldData +}; + +BGD_EXPORT_DATA_PROT gdFontPtr gdFontMediumBold = &gdFontMediumBoldRep; + +BGD_DECLARE(gdFontPtr) +gdFontGetMediumBold (void) +{ + return gdFontMediumBold; +} + +/* This file has not been truncated. */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdfontmb.h b/Build/source/libs/gd/libgd-2.1.1/src/gdfontmb.h new file mode 100644 index 00000000000..e6807db4eb8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdfontmb.h @@ -0,0 +1,27 @@ +#ifndef _GDFONTMB_H_ +#define _GDFONTMB_H_ 1 + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* + This is a header file for gd font, generated using + bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz + from bdf font + -misc-fixed-bold-r-normal-sans-13-94-100-100-c-70-iso8859-2 + at Thu Jan 8 13:54:57 1998. + No copyright info was found in the original bdf. + */ + +#include "gd.h" + +extern BGD_EXPORT_DATA_PROT gdFontPtr gdFontMediumBold; +BGD_DECLARE(gdFontPtr) gdFontGetMediumBold(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdfonts.c b/Build/source/libs/gd/libgd-2.1.1/src/gdfonts.c new file mode 100644 index 00000000000..f7c27250362 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdfonts.c @@ -0,0 +1,3876 @@ +/* + This is a header file for gd font, generated using + bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz + from bdf font + -misc-fixed-medium-r-semicondensed-sans-12-116-75-75-c-60-iso8859-2 + at Thu Jan 8 14:13:20 1998. + No copyright info was found in the original bdf. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gdfonts.h" + +char gdFontSmallData[] = { + /* Char 0 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 1 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 2 */ + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, + + /* Char 3 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, + 1, 0, 1, 0, 0, 0, + 1, 1, 1, 0, 0, 0, + 1, 0, 1, 0, 0, 0, + 1, 0, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 4 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 1, 1, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 5 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 6 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 7 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 1, 0, 0, 1, 0, 0, + 1, 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 8 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 9 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, + + /* Char 10 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 11 */ + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 12 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + + /* Char 13 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 1, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + + /* Char 14 */ + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 15 */ + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + + /* Char 16 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 17 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 18 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 19 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 20 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 21 */ + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 1, 1, 1, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + + /* Char 22 */ + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 1, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + + /* Char 23 */ + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 24 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + + /* Char 25 */ + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + + /* Char 26 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 27 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 28 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 29 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 30 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 31 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 32 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 33 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 34 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 35 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 1, 0, 1, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 36 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 1, 0, + 1, 0, 1, 0, 0, 0, + 1, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 1, 0, + 0, 0, 1, 0, 1, 0, + 1, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 37 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 38 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, + 1, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, + 1, 0, 0, 1, 1, 0, + 1, 0, 0, 1, 0, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 39 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 40 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 41 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 42 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 1, 0, 1, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 43 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 44 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 45 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 46 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 47 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 48 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 49 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 1, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 50 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 51 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 52 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 1, 0, 0, + 1, 0, 0, 1, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 53 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 54 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 55 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 56 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 57 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 1, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 58 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 59 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 60 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 61 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 62 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 63 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 64 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 65 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 66 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 67 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 68 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 69 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 70 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 71 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 72 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 73 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 74 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 1, 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 75 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, + 1, 0, 1, 0, 0, 0, + 1, 1, 1, 0, 0, 0, + 1, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 76 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 77 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 0, 1, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 78 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 1, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 1, 0, 0, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 79 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 80 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 81 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 82 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 1, 0, 0, 0, + 1, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 83 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 84 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 85 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 86 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 87 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 88 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 89 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 90 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 91 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 92 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 93 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 94 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 95 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 96 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 97 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 98 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 99 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 100 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 101 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 102 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 103 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + + /* Char 104 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 105 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 106 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 1, 0, 0, 1, 0, 0, + 1, 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, 0, + + /* Char 107 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, 0, + 1, 0, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, + 1, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 108 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 109 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 0, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 110 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 111 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 112 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + + /* Char 113 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, 0, + + /* Char 114 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 115 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 116 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 117 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 118 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 119 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 120 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 121 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 1, 1, 1, 0, 0, 0, + + /* Char 122 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 123 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 124 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 125 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 1, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 126 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 127 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 128 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 129 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 130 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 131 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 132 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 133 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 134 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 135 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 136 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 137 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 138 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 139 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 140 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 141 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 142 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 143 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 144 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 145 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 146 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 147 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 148 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 149 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 150 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 151 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 152 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 153 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 154 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 155 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 156 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 157 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 158 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 159 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 160 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 161 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 1, + + /* Char 162 */ + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 163 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 164 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 165 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, 0, + 1, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 166 */ + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 167 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 1, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 1, 0, 0, 1, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 168 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 169 */ + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 170 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + + /* Char 171 */ + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 172 */ + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 173 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 174 */ + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 175 */ + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 176 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 1, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 177 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 1, 1, + + /* Char 178 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + + /* Char 179 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 180 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 181 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, + 0, 1, 1, 0, 0, 1, + 0, 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 182 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 183 */ + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 184 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, 0, + + /* Char 185 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 186 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + + /* Char 187 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 188 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 189 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 1, + 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 190 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 191 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 192 */ + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 1, 0, 0, 0, + 1, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 193 */ + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 194 */ + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 195 */ + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 196 */ + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 197 */ + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 198 */ + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 199 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, 0, + + /* Char 200 */ + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 201 */ + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 202 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + + /* Char 203 */ + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 204 */ + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 205 */ + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 206 */ + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 207 */ + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 208 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 1, 0, + 1, 1, 1, 0, 1, 0, + 0, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 1, 0, + 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 209 */ + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 1, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 1, 0, 0, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 210 */ + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 1, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 1, 0, 0, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 211 */ + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 212 */ + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 213 */ + 0, 0, 1, 0, 0, 1, + 0, 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 214 */ + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 215 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 216 */ + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 1, 0, 0, 0, + 1, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 217 */ + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 218 */ + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 219 */ + 0, 0, 1, 0, 0, 1, + 0, 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 220 */ + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 221 */ + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 222 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + + /* Char 223 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 224 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 225 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 226 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 227 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 228 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 0, + 0, 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 229 */ + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 230 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 231 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, 0, + + /* Char 232 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 233 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 234 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + + /* Char 235 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 236 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 237 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 238 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 239 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 1, + 0, 0, 0, 0, 0, 1, + 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 1, 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, 0, + 1, 0, 0, 1, 0, 0, + 1, 0, 0, 1, 0, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 240 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 1, 1, + 0, 0, 0, 0, 1, 0, + 0, 1, 1, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 241 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 242 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 243 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 244 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 245 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 246 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 247 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 248 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 1, 1, 0, 0, + 1, 1, 0, 0, 1, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 249 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 250 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 251 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 252 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + /* Char 253 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 0, 1, 0, + 1, 0, 0, 1, 1, 0, + 0, 1, 1, 0, 1, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, 0, + 1, 1, 1, 0, 0, 0, + + /* Char 254 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 1, 0, 0, 1, 0, + 0, 0, 1, 1, 0, 0, + 0, 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, 0, + + /* Char 255 */ + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, + + +}; + +gdFont gdFontSmallRep = { + 256, + 0, + 6, + 13, + gdFontSmallData +}; + +BGD_EXPORT_DATA_PROT gdFontPtr gdFontSmall = &gdFontSmallRep; + +BGD_DECLARE(gdFontPtr) +gdFontGetSmall (void) +{ + return gdFontSmall; +} + +/* This file has not been truncated. */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdfonts.h b/Build/source/libs/gd/libgd-2.1.1/src/gdfonts.h new file mode 100644 index 00000000000..b5127e971a6 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdfonts.h @@ -0,0 +1,27 @@ +#ifndef _GDFONTS_H_ +#define _GDFONTS_H_ 1 + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* + This is a header file for gd font, generated using + bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz + from bdf font + -misc-fixed-medium-r-semicondensed-sans-12-116-75-75-c-60-iso8859-2 + at Thu Jan 8 14:13:20 1998. + No copyright info was found in the original bdf. + */ + +#include "gd.h" + +extern BGD_EXPORT_DATA_PROT gdFontPtr gdFontSmall; +BGD_DECLARE(gdFontPtr) gdFontGetSmall(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdfontt.c b/Build/source/libs/gd/libgd-2.1.1/src/gdfontt.c new file mode 100644 index 00000000000..c9c6f4a31da --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdfontt.c @@ -0,0 +1,2599 @@ + + +/* + This is a header file for gd font, generated using + bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz + from bdf font + -Misc-Fixed-Medium-R-Normal--8-80-75-75-C-50-ISO8859-2 + at Thu Jan 8 13:49:54 1998. + The original bdf was holding following copyright: + "Libor Skarvada, libor@informatics.muni.cz" + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gdfontt.h" + +char gdFontTinyData[] = { + /* Char 0 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 1 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 1, 1, 1, 1, 1, + 0, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 2 */ + 0, 1, 0, 1, 0, + 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 1, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 1, 0, 1, 0, 0, + + /* Char 3 */ + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 1, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 1, 1, 1, + 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, + + /* Char 4 */ + 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 0, 0, 0, + 1, 0, 1, 1, 1, + 1, 0, 1, 0, 0, + 0, 0, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + + /* Char 5 */ + 0, 1, 1, 0, 0, + 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, + 0, 0, 1, 0, 1, + 0, 0, 1, 1, 0, + 0, 0, 1, 0, 1, + + /* Char 6 */ + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 0, 0, 1, 1, 1, + 0, 0, 1, 0, 0, + 0, 0, 1, 1, 0, + 0, 0, 1, 0, 0, + + /* Char 7 */ + 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, + 1, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 8 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 9 */ + 1, 0, 0, 1, 0, + 1, 1, 0, 1, 0, + 1, 0, 1, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, + + /* Char 10 */ + 1, 0, 1, 0, 0, + 1, 0, 1, 0, 0, + 1, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 1, 1, + 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, + + /* Char 11 */ + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 12 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + + /* Char 13 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + + /* Char 14 */ + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 15 */ + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 1, 1, 1, 1, 1, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + + /* Char 16 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 17 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 18 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 19 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 20 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 21 */ + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 1, 1, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + + /* Char 22 */ + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 1, 1, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + + /* Char 23 */ + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 24 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + + /* Char 25 */ + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + + /* Char 26 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 27 */ + 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 28 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 29 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, + 1, 1, 1, 1, 1, + 0, 0, 1, 0, 0, + 1, 1, 1, 1, 1, + 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 30 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, + 0, 1, 0, 0, 1, + 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 0, 1, + 1, 0, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 31 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 32 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 33 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 34 */ + 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 35 */ + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 1, 1, 1, 1, 1, + 0, 1, 0, 1, 0, + 1, 1, 1, 1, 1, + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 36 */ + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 1, 0, 1, + 0, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 37 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, + 1, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 1, 1, + 1, 0, 0, 1, 1, + 0, 0, 0, 0, 0, + + /* Char 38 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 1, + 0, 0, 0, 0, 0, + + /* Char 39 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 40 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 41 */ + 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 42 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 1, 1, 1, 1, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 43 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 1, 1, 1, 1, 1, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 44 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 45 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 46 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 47 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 48 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 49 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 50 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 51 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 52 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 1, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 53 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 54 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 1, 0, 0, + 1, 1, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 55 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 56 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 57 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 58 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 59 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, + 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + + /* Char 60 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 61 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 62 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 63 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 64 */ + 0, 0, 1, 1, 0, + 0, 1, 0, 0, 1, + 1, 0, 0, 1, 1, + 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, + 1, 0, 0, 1, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 1, 0, + + /* Char 65 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 66 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 67 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 68 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 69 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 70 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 71 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 1, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 72 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 73 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 74 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 75 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 0, 0, + 1, 1, 0, 0, 0, + 1, 0, 1, 0, 0, + 1, 0, 1, 0, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 76 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 77 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 1, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 78 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 0, 1, 0, + 1, 1, 1, 1, 0, + 1, 0, 1, 1, 0, + 1, 0, 1, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 79 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 80 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 81 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 1, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 1, 0, + + /* Char 82 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 1, 0, 1, 0, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 83 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 84 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 85 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 86 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 87 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 1, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 88 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 89 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, + 1, 0, 0, 0, 1, + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 90 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 91 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 92 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, + + /* Char 93 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 94 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 95 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, + + /* Char 96 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 97 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 98 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 99 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 100 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 101 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 1, 1, 0, + 1, 1, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 102 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 0, 1, 0, 0, 0, + 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 103 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + + /* Char 104 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 105 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 106 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + + /* Char 107 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 108 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 109 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 0, 1, 0, + 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, + 1, 0, 0, 0, 1, + 0, 0, 0, 0, 0, + + /* Char 110 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, + 1, 1, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 111 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 112 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + + /* Char 113 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 1, 0, + 0, 0, 0, 1, 0, + + /* Char 114 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, + 1, 1, 0, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 115 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 116 */ + 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, + 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 117 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 118 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 119 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, + 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 120 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 121 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + + /* Char 122 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 123 */ + 0, 0, 1, 1, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 1, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 124 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 125 */ + 0, 1, 1, 0, 0, + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, + 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 126 */ + 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, + 1, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 127 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 128 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 129 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 130 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 131 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 132 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 133 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 134 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 135 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 136 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 137 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 138 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 139 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 140 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 141 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 142 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 143 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 144 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 145 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 146 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 147 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 148 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 149 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 150 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 151 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 152 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 153 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 154 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 155 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 156 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 157 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 158 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 159 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 160 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 161 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 0, 0, 1, 1, + + /* Char 162 */ + 1, 0, 0, 0, 1, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 163 */ + 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 1, 0, 0, 0, + 1, 1, 0, 0, 0, + 0, 1, 1, 1, 1, + 0, 0, 0, 0, 0, + + /* Char 164 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 0, 1, + 0, 1, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 0, 1, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 165 */ + 0, 0, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 166 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 167 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 1, 0, + 0, 1, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + + /* Char 168 */ + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 169 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 170 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, + + /* Char 171 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 1, 1, 1, 1, 1, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 172 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 173 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 174 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 175 */ + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 176 */ + 0, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 177 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 1, 1, + + /* Char 178 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 1, 1, + + /* Char 179 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 180 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 181 */ + 0, 0, 0, 1, 1, + 1, 1, 0, 0, 1, + 0, 1, 0, 1, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 182 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 183 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 184 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + + /* Char 185 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 186 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 1, 0, 0, 0, + 0, 0, 1, 1, 0, + 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, + + /* Char 187 */ + 0, 0, 0, 1, 1, + 0, 1, 0, 0, 1, + 0, 1, 0, 1, 0, + 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 188 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 189 */ + 0, 1, 0, 0, 1, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 190 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 191 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 192 */ + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 1, 0, 1, 0, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 193 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 194 */ + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 195 */ + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 196 */ + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 197 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 198 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 199 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 1, 1, 0, 0, 0, + + /* Char 200 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 201 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 202 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 1, 1, + + /* Char 203 */ + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 204 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 205 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 206 */ + 0, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 207 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 208 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 0, 0, + 0, 1, 0, 1, 0, + 1, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 0, 1, 0, 1, 0, + 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 209 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 0, 1, 0, + 1, 1, 1, 1, 0, + 1, 0, 1, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 210 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 0, 1, 0, + 1, 1, 1, 1, 0, + 1, 0, 1, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 211 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 212 */ + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 213 */ + 0, 1, 0, 0, 1, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 214 */ + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 215 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 216 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 1, 0, 1, 0, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 217 */ + 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 218 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 219 */ + 0, 1, 0, 0, 1, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 220 */ + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 221 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 222 */ + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, + + /* Char 223 */ + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 1, 0, 1, 0, + 1, 0, 1, 0, 0, + 1, 0, 0, 0, 0, + + /* Char 224 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, + 1, 1, 0, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 225 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 226 */ + 0, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 227 */ + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 228 */ + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 229 */ + 0, 0, 0, 0, 1, + 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 230 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 231 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 1, 1, 0, 0, + + /* Char 232 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 233 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 1, 1, 0, + 1, 1, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 234 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 1, 1, 0, + 1, 1, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 1, 1, + + /* Char 235 */ + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 1, 1, 0, + 1, 1, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 236 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 1, 1, 0, + 1, 1, 0, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 237 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 238 */ + 0, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 239 */ + 0, 0, 0, 1, 1, + 0, 0, 1, 0, 1, + 0, 0, 1, 0, 1, + 0, 1, 1, 0, 0, + 1, 0, 1, 0, 0, + 1, 0, 1, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 240 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 1, 1, + 0, 0, 0, 1, 0, + 0, 1, 1, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 241 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, + 1, 1, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 242 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, + 1, 1, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 243 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 244 */ + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 245 */ + 0, 1, 0, 0, 1, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 246 */ + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 247 */ + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, + 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 248 */ + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, + 1, 1, 0, 1, 0, + 1, 0, 0, 0, 0, + 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + /* Char 249 */ + 0, 1, 1, 0, 0, + 0, 1, 1, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 250 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 251 */ + 0, 1, 0, 0, 1, + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 252 */ + 1, 0, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 1, 0, 1, 1, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + + /* Char 253 */ + 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 1, 0, 0, 1, 0, + 1, 0, 0, 1, 0, + 0, 1, 1, 1, 0, + 0, 0, 0, 1, 0, + 0, 1, 1, 0, 0, + + /* Char 254 */ + 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 0, 0, + 1, 1, 1, 0, 0, + 0, 1, 0, 0, 0, + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0, + 0, 1, 1, 0, 0, + + /* Char 255 */ + 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + + +}; + +gdFont gdFontTinyRep = { + 256, + 0, + 5, + 8, + gdFontTinyData +}; + +BGD_EXPORT_DATA_PROT gdFontPtr gdFontTiny = &gdFontTinyRep; + +BGD_DECLARE(gdFontPtr) +gdFontGetTiny (void) +{ + return gdFontTiny; +} + +/* This file has not been truncated. */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdfontt.h b/Build/source/libs/gd/libgd-2.1.1/src/gdfontt.h new file mode 100644 index 00000000000..d61b01ff4a0 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdfontt.h @@ -0,0 +1,28 @@ +#ifndef _GDFONTT_H_ +#define _GDFONTT_H_ 1 + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* + This is a header file for gd font, generated using + bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz + from bdf font + -Misc-Fixed-Medium-R-Normal--8-80-75-75-C-50-ISO8859-2 + at Thu Jan 8 13:49:54 1998. + The original bdf was holding following copyright: + "Libor Skarvada, libor@informatics.muni.cz" + */ + +#include "gd.h" + +extern BGD_EXPORT_DATA_PROT gdFontPtr gdFontTiny; +BGD_DECLARE(gdFontPtr) gdFontGetTiny(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdft.c b/Build/source/libs/gd/libgd-2.1.1/src/gdft.c new file mode 100644 index 00000000000..03a01593660 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdft.c @@ -0,0 +1,1764 @@ + +/********************************************/ +/* gd interface to freetype library */ +/* */ +/* John Ellson ellson@graphviz.org */ +/********************************************/ + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <math.h> + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gd.h" +#include "gdhelpers.h" +#include "entities.h" +#include "gd_intern.h" + +/* 2.0.10: WIN32, not MSWIN32 */ +#if !defined(_WIN32) && !defined(_WIN32_WCE) +#include <unistd.h> +#elif defined(_WIN32_WCE) +#include <wce_stdlib.h> /* getenv() */ +#include <wce_unistd.h> /* access() */ +#define getenv wceex_getenv +#define access wceex_access +#else /* _WIN32_WCE */ +#include <io.h> +#ifndef R_OK +#define R_OK 04 /* Needed in Windows */ +#endif +#endif + +/* number of antialised colors for indexed bitmaps */ +#define GD_NUMCOLORS 8 + +#ifdef HAVE_LIBFONTCONFIG +static int fontConfigFlag = 0; + +/* translate a fontconfig fontpattern into a fontpath. + return NULL if OK, else return error string */ +static char *font_pattern(char **fontpath, char *fontpattern); +#endif + +static char *font_path(char **fontpath, char *name_list); + +/* 2.0.30: move these up here so we can build correctly without freetype + but with fontconfig */ + +/* + * The character (space) used to separate alternate fonts in the + * fontlist parameter to gdImageStringFT. 2.0.18: space was a + * poor choice for this. + */ +#define LISTSEPARATOR ";" + +/* + * DEFAULT_FONTPATH and PATHSEPARATOR are host type dependent and + * are normally set by configure in config.h. These are just + * some last resort values that might match some Un*x system + * if building this version of gd separate from graphviz. + */ + +#ifndef DEFAULT_FONTPATH +# ifdef NETWARE +# define DEFAULT_FONTPATH "sys:/java/nwgfx/lib/x11/fonts/ttf;." +# elif defined(_WIN32) +# define DEFAULT_FONTPATH "C:\\WINDOWS\\FONTS;C:\\WINNT\\FONTS" +# elif defined(__APPLE__) || (defined(__MWERKS__) && defined(macintosh)) +# define DEFAULT_FONTPATH "/usr/share/fonts/truetype:/System/Library/Fonts:/Library/Fonts" +# else + /* default fontpath for unix systems - whatever happened to standards ! */ +# define DEFAULT_FONTPATH "/usr/X11R6/lib/X11/fonts/TrueType:/usr/X11R6/lib/X11/fonts/truetype:/usr/X11R6/lib/X11/fonts/TTF:/usr/share/fonts/TrueType:/usr/share/fonts/truetype:/usr/openwin/lib/X11/fonts/TrueType:/usr/X11R6/lib/X11/fonts/Type1:/usr/lib/X11/fonts/Type1:/usr/openwin/lib/X11/fonts/Type1" +# endif +#endif + +#ifndef PATHSEPARATOR +# if defined(NETWARE) || defined(_WIN32) +# define PATHSEPARATOR ";" +# else +# define PATHSEPARATOR ":" +# endif +#endif + + +#ifndef TRUE +#define FALSE 0 +#define TRUE !FALSE +#endif + +BGD_DECLARE(char *) gdImageStringTTF (gdImage * im, int *brect, int fg, char *fontlist, + double ptsize, double angle, int x, int y, char *string) +{ + /* 2.0.6: valid return */ + return gdImageStringFT (im, brect, fg, fontlist, ptsize, + angle, x, y, string); +} + +#ifndef HAVE_LIBFREETYPE +BGD_DECLARE(char *) gdImageStringFTEx (gdImage * im, int *brect, int fg, char *fontlist, + double ptsize, double angle, int x, int y, char *string, + gdFTStringExtraPtr strex) +{ + (void)im; + (void)brect; + (void)fg; + (void)fontlist; + (void)ptsize; + (void)angle; + (void)x; + (void)y; + (void)string; + (void)strex; + + return "libgd was not built with FreeType font support\n"; +} + +BGD_DECLARE(char *) gdImageStringFT (gdImage * im, int *brect, int fg, char *fontlist, + double ptsize, double angle, int x, int y, char *string) +{ + (void)im; + (void)brect; + (void)fg; + (void)fontlist; + (void)ptsize; + (void)angle; + (void)x; + (void)y; + (void)string; + + return "libgd was not built with FreeType font support\n"; +} +#else + +#ifndef HAVE_LIBFONTCONFIG +static char * font_pattern(char **fontpath, char *fontpattern) +{ + (void)fontpath; + (void)fontpattern; + + return "libgd was not built with FontConfig support\n"; +} +#endif /* HAVE_LIBFONTCONFIG */ + +#include "gdcache.h" +/* 2.0.16 Christophe Thomas: starting with FreeType 2.1.6, this is + mandatory, and it has been supported for a long while. */ +#ifdef HAVE_FT2BUILD_H +#include <ft2build.h> +#include FT_FREETYPE_H +#include FT_GLYPH_H +#include FT_SIZES_H +#else +#include <freetype/freetype.h> +#include <freetype/ftglyph.h> +#include <freetype/ftsizes.h> +#endif + +/* number of fonts cached before least recently used is replaced */ +#define FONTCACHESIZE 6 + +/* number of antialias color lookups cached */ +#define TWEENCOLORCACHESIZE 32 + +/* + * Line separation as a factor of font height. + * No space between if LINESPACE = 1.00 + * Line separation will be rounded up to next pixel row. + */ +#define LINESPACE 1.05 + +typedef struct { + char *fontlist; /* key */ + int flags; /* key */ + char *fontpath; + FT_Library *library; + FT_Face face; +} +font_t; + +typedef struct { + char *fontlist; /* key */ + int flags; /* key */ + FT_Library *library; +} +fontkey_t; + +typedef struct { + int pixel; /* key */ + int bgcolor; /* key */ + int fgcolor; /* key *//* -ve means no antialias */ + gdImagePtr im; /* key */ + int tweencolor; +} +tweencolor_t; + +typedef struct { + int pixel; /* key */ + int bgcolor; /* key */ + int fgcolor; /* key *//* -ve means no antialias */ + gdImagePtr im; /* key */ +} +tweencolorkey_t; + +/******************************************************************** + * gdTcl_UtfToUniChar is borrowed from Tcl ... + */ +/* + * tclUtf.c -- + * + * Routines for manipulating UTF-8 strings. + * + * Copyright (c) 1997-1998 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tclUtf.c 1.25 98/01/28 18:02:43 + */ + +/* + *--------------------------------------------------------------------------- + * + * gdTcl_UtfToUniChar -- + * + * Extract the Tcl_UniChar represented by the UTF-8 string. Bad + * UTF-8 sequences are converted to valid Tcl_UniChars and processing + * continues. Equivalent to Plan 9 chartorune(). + * + * The caller must ensure that the source buffer is long enough that + * this routine does not run off the end and dereference non-existent + * memory looking for trail bytes. If the source buffer is known to + * be '\0' terminated, this cannot happen. Otherwise, the caller + * should call Tcl_UtfCharComplete() before calling this routine to + * ensure that enough bytes remain in the string. + * + * Results: + * *chPtr is filled with the Tcl_UniChar, and the return value is the + * number of bytes from the UTF-8 string that were consumed. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ + +#ifdef JISX0208 +#include "jisx0208.h" +#endif + +static int comp_entities(const void *e1, const void *e2) +{ + struct entities_s *en1 = (struct entities_s *) e1; + struct entities_s *en2 = (struct entities_s *) e2; + return strcmp(en1->name, en2->name); +} + +extern int any2eucjp (char *, char *, unsigned int); + +/* Persistent font cache until explicitly cleared */ +/* Fonts can be used across multiple images */ + +/* 2.0.16: thread safety (the font cache is shared) */ +gdMutexDeclare (gdFontCacheMutex); +static gdCache_head_t *fontCache; +static FT_Library library; + +#define Tcl_UniChar int +#define TCL_UTF_MAX 3 +static int +gdTcl_UtfToUniChar (char *str, Tcl_UniChar * chPtr) +/* str is the UTF8 next character pointer */ +/* chPtr is the int for the result */ +{ + int byte; + char entity_name_buf[ENTITY_NAME_LENGTH_MAX+1]; + char *p; + struct entities_s key, *res; + + /* HTML4.0 entities in decimal form, e.g. Å */ + /* or in hexadecimal form, e.g. 水 */ + byte = *((unsigned char *) str); + if (byte == '&') { + int i, n = 0; + + byte = *((unsigned char *) (str + 1)); + if (byte == '#') { + byte = *((unsigned char *) (str + 2)); + if (byte == 'x' || byte == 'X') { + for (i = 3; i < 8; i++) { + byte = *((unsigned char *) (str + i)); + if (byte >= 'A' && byte <= 'F') + byte = byte - 'A' + 10; + else if (byte >= 'a' && byte <= 'f') + byte = byte - 'a' + 10; + else if (byte >= '0' && byte <= '9') + byte = byte - '0'; + else + break; + n = (n * 16) + byte; + } + } else { + for (i = 2; i < 8; i++) { + byte = *((unsigned char *) (str + i)); + if (byte >= '0' && byte <= '9') + n = (n * 10) + (byte - '0'); + else + break; + } + } + if (byte == ';') { + *chPtr = (Tcl_UniChar) n; + return ++i; + } + } else { + key.name = p = entity_name_buf; + for (i = 1; i <= 1 + ENTITY_NAME_LENGTH_MAX; i++) { + byte = *((unsigned char *) (str + i)); + if (byte == '\0') + break; + if (byte == ';') { + *p++ = '\0'; + res = bsearch(&key, entities, NR_OF_ENTITIES, + sizeof(entities[0]), *comp_entities); + if (res) { + *chPtr = (Tcl_UniChar) res->value; + return ++i; + } + break; + } + *p++ = byte; + } + } + } + + /* + * Unroll 1 to 3 byte UTF-8 sequences, use loop to handle longer ones. + */ + + byte = *((unsigned char *) str); +#ifdef JISX0208 + if (0xA1 <= byte && byte <= 0xFE) { + int ku, ten; + + ku = (byte & 0x7F) - 0x20; + ten = (str[1] & 0x7F) - 0x20; + if ((ku < 1 || ku > 92) || (ten < 1 || ten > 94)) { + *chPtr = (Tcl_UniChar) byte; + return 1; + } + + *chPtr = (Tcl_UniChar) UnicodeTbl[ku - 1][ten - 1]; + return 2; + } else +#endif /* JISX0208 */ + if (byte < 0xC0) { + /* + * Handles properly formed UTF-8 characters between + * 0x01 and 0x7F. Also treats \0 and naked trail + * bytes 0x80 to 0xBF as valid characters representing + * themselves. + */ + + *chPtr = (Tcl_UniChar) byte; + return 1; + } else if (byte < 0xE0) { + if ((str[1] & 0xC0) == 0x80) { + /* + * Two-byte-character lead-byte followed + * by a trail-byte. + */ + + *chPtr = (Tcl_UniChar) (((byte & 0x1F) << 6) | (str[1] & 0x3F)); + return 2; + } + /* + * A two-byte-character lead-byte not followed by trail-byte + * represents itself. + */ + + *chPtr = (Tcl_UniChar) byte; + return 1; + } else if (byte < 0xF0) { + if (((str[1] & 0xC0) == 0x80) && ((str[2] & 0xC0) == 0x80)) { + /* + * Three-byte-character lead byte followed by + * two trail bytes. + */ + + *chPtr = (Tcl_UniChar) (((byte & 0x0F) << 12) + | ((str[1] & 0x3F) << 6) | (str[2] & 0x3F)); + return 3; + } + /* + * A three-byte-character lead-byte not followed by + * two trail-bytes represents itself. + */ + + *chPtr = (Tcl_UniChar) byte; + return 1; + } +#if TCL_UTF_MAX > 3 + else { + int ch, total, trail; + + total = totalBytes[byte]; + trail = total - 1; + if (trail > 0) { + ch = byte & (0x3F >> trail); + do { + str++; + if ((*str & 0xC0) != 0x80) { + *chPtr = byte; + return 1; + } + ch <<= 6; + ch |= (*str & 0x3F); + trail--; + } while (trail > 0); + *chPtr = ch; + return total; + } + } +#endif + + *chPtr = (Tcl_UniChar) byte; + return 1; +} + +/********************************************************************/ +/* font cache functions */ + +static int +fontTest (void *element, void *key) +{ + font_t *a = (font_t *) element; + fontkey_t *b = (fontkey_t *) key; + + return (strcmp (a->fontlist, b->fontlist) == 0 && a->flags == b->flags); +} + +static int useFontConfig(int flag) +{ +#ifdef HAVE_LIBFONTCONFIG + if (fontConfigFlag) { + return (!(flag & gdFTEX_FONTPATHNAME)); + } else +#endif + { + return flag & gdFTEX_FONTCONFIG; + + } + return flag & gdFTEX_FONTCONFIG; +} + +static void * +fontFetch (char **error, void *key) +{ + font_t *a; + fontkey_t *b = (fontkey_t *) key; + char *suffix; + FT_Error err; + const unsigned int b_font_list_len = strlen(b->fontlist); + + *error = NULL; + + a = (font_t *) gdMalloc (sizeof (font_t)); + if (!a) { + return NULL; + } + + a->fontlist = (char *) gdMalloc(b_font_list_len + 1); + if (a->fontlist == NULL) { + gdFree(a); + return "could not alloc full list of fonts"; + } + strncpy(a->fontlist, b->fontlist, b_font_list_len); + a->fontlist[b_font_list_len] = 0; + + a->flags = b->flags; + a->library = b->library; + a->fontpath = NULL; + +#ifdef HAVE_LIBFONTCONFIG + if (!useFontConfig(b->flags)) + *error = font_path(&(a->fontpath), a->fontlist); + else + *error = font_pattern(&(a->fontpath), a->fontlist); +#else + *error = font_path(&(a->fontpath), a->fontlist); +#endif /* HAVE_LIBFONTCONFIG */ + if (*error || !a->fontpath || !a->fontpath[0]) { + gdFree(a->fontlist); + if (a->fontpath) + free(a->fontpath); + gdFree(a); + + if (!*error) + *error = "font_path() returned an empty font pathname"; + + return NULL; + } + + err = FT_New_Face(*b->library, a->fontpath, 0, &a->face); + + /* Read kerning metrics for Postscript fonts. */ + if (!err + && ((suffix = strstr(a->fontpath, ".pfa")) + || (suffix = strstr(a->fontpath, ".pfb"))) + && ((strcpy(suffix, ".afm") && (access(a->fontpath, R_OK) == 0)) + || (strcpy(suffix, ".pfm") && (access(a->fontpath, R_OK) == 0)))) { + err = FT_Attach_File(a->face, a->fontpath); + } + + if (err) { + gdFree (a->fontlist); + free(a->fontpath); + gdFree(a); + *error = "Could not read font"; + return NULL; + } + + return (void *) a; +} + +static void +fontRelease (void *element) +{ + font_t *a = (font_t *) element; + + FT_Done_Face (a->face); + gdFree (a->fontlist); + gdFree (a->fontpath); + gdFree ((char *) element); +} + +/********************************************************************/ +/* tweencolor cache functions */ + +static int +tweenColorTest (void *element, void *key) +{ + tweencolor_t *a = (tweencolor_t *) element; + tweencolorkey_t *b = (tweencolorkey_t *) key; + + return (a->pixel == b->pixel + && a->bgcolor == b->bgcolor + && a->fgcolor == b->fgcolor && a->im == b->im); +} + +/* + * Computes a color in im's color table that is part way between + * the background and foreground colors proportional to the gray + * pixel value in the range 0-GD_NUMCOLORS. The fg and bg colors must already + * be in the color table for palette images. For truecolor images the + * returned value simply has an alpha component and gdImageAlphaBlend + * does the work so that text can be alpha blended across a complex + * background (TBB; and for real in 2.0.2). + */ +static void * +tweenColorFetch (char **error, void *key) +{ + tweencolor_t *a; + tweencolorkey_t *b = (tweencolorkey_t *) key; + int pixel, npixel, bg, fg; + gdImagePtr im; + + (void)error; + + a = (tweencolor_t *) gdMalloc (sizeof (tweencolor_t)); + if (!a) { + return NULL; + } + + pixel = a->pixel = b->pixel; + bg = a->bgcolor = b->bgcolor; + fg = a->fgcolor = b->fgcolor; + im = a->im = b->im; + + /* if fg is specified by a negative color idx, then don't antialias */ + if (fg < 0) { + if ((pixel + pixel) >= GD_NUMCOLORS) + a->tweencolor = -fg; + else + a->tweencolor = bg; + } else { + npixel = GD_NUMCOLORS - pixel; + if (im->trueColor) { + /* 2.0.1: use gdImageSetPixel to do the alpha blending work, + or to just store the alpha level. All we have to do here + is incorporate our knowledge of the percentage of this + pixel that is really "lit" by pushing the alpha value + up toward transparency in edge regions. */ + a->tweencolor = gdTrueColorAlpha (gdTrueColorGetRed (fg), + gdTrueColorGetGreen (fg), + gdTrueColorGetBlue (fg), + gdAlphaMax - + (gdTrueColorGetAlpha (fg) * + pixel / GD_NUMCOLORS)); + } else { + a->tweencolor = gdImageColorResolve (im, + (pixel * im->red[fg] + + npixel * im->red[bg]) / + GD_NUMCOLORS, + (pixel * im->green[fg] + + npixel * im->green[bg]) / + GD_NUMCOLORS, + (pixel * im->blue[fg] + + npixel * im->blue[bg]) / + GD_NUMCOLORS); + } + } + return (void *) a; +} + +static void +tweenColorRelease (void *element) +{ + gdFree ((char *) element); +} + +/* draw_bitmap - transfers glyph bitmap to GD image */ +static char * +gdft_draw_bitmap (gdCache_head_t * tc_cache, gdImage * im, int fg, + FT_Bitmap bitmap, int pen_x, int pen_y) +{ + unsigned char *pixel = NULL; + int *tpixel = NULL; + int opixel; + int x, y, row, col, pc, pcr; + + tweencolor_t *tc_elem; + tweencolorkey_t tc_key; + + /* copy to image, mapping colors */ + tc_key.fgcolor = fg; + tc_key.im = im; + /* Truecolor version; does not require the cache */ + if (im->trueColor) { + for (row = 0; row < bitmap.rows; row++) { + pc = row * bitmap.pitch; + pcr = pc; + y = pen_y + row; + /* clip if out of bounds */ + /* 2.0.16: clipping rectangle, not image bounds */ + if ((y > im->cy2) || (y < im->cy1)) + continue; + for (col = 0; col < bitmap.width; col++, pc++) { + int level; + if (bitmap.pixel_mode == ft_pixel_mode_grays) { + /* + * Scale to 128 levels of alpha for gd use. + * alpha 0 is opacity, so be sure to invert at the end + */ + level = (bitmap.buffer[pc] * gdAlphaMax / + (bitmap.num_grays - 1)); + } else if (bitmap.pixel_mode == ft_pixel_mode_mono) { + /* 2.0.5: mode_mono fix from Giuliano Pochini */ + level = + ((bitmap. + buffer[(col >> 3) + + pcr]) & (1 << (~col & 0x07))) ? + gdAlphaTransparent : gdAlphaOpaque; + } else { + return "Unsupported ft_pixel_mode"; + } + if (level == 0) /* if background */ + continue; + + if ((fg >= 0) && (im->trueColor)) { + /* Consider alpha in the foreground color itself to be an + upper bound on how opaque things get, when truecolor is + available. Without truecolor this results in far too many + color indexes. */ + level = + level * (gdAlphaMax - + gdTrueColorGetAlpha (fg)) / gdAlphaMax; + } + level = gdAlphaMax - level; /* inverting to get alpha */ + x = pen_x + col; + /* clip if out of bounds */ + /* 2.0.16: clip to clipping rectangle, Matt McNabb */ + if ((x > im->cx2) || (x < im->cx1)) + continue; + /* get pixel location in gd buffer */ + tpixel = &im->tpixels[y][x]; + if (fg < 0) { + if (level < (gdAlphaMax / 2)) { + *tpixel = -fg; + } + } else { + if (im->alphaBlendingFlag) { + opixel = *tpixel; + if (gdTrueColorGetAlpha(opixel) != gdAlphaTransparent) { + *tpixel = gdAlphaBlend (opixel, + (level << 24) + (fg & 0xFFFFFF)); + } else { + *tpixel = (level << 24) + (fg & 0xFFFFFF); + } + } else { + *tpixel = (level << 24) + (fg & 0xFFFFFF); + } + } + } + } + return (char *) NULL; + } + /* Non-truecolor case, restored to its more or less original form */ + for (row = 0; row < bitmap.rows; row++) { + int pcr; + pc = row * bitmap.pitch; + pcr = pc; + if (bitmap.pixel_mode == ft_pixel_mode_mono) + pc *= 8; /* pc is measured in bits for monochrome images */ + + y = pen_y + row; + + /* clip if out of bounds */ + if (y > im->cy2 || y < im->cy1) + continue; + + for (col = 0; col < bitmap.width; col++, pc++) { + if (bitmap.pixel_mode == ft_pixel_mode_grays) { + /* + * Round to GD_NUMCOLORS levels of antialiasing for + * index color images since only 256 colors are + * available. + */ + tc_key.pixel = ((bitmap.buffer[pc] * GD_NUMCOLORS) + + bitmap.num_grays / 2) + / (bitmap.num_grays - 1); + } else if (bitmap.pixel_mode == ft_pixel_mode_mono) { + tc_key.pixel = ((bitmap.buffer[pc / 8] + << (pc % 8)) & 128) ? GD_NUMCOLORS : 0; + /* 2.0.5: mode_mono fix from Giuliano Pochini */ + tc_key.pixel = + ((bitmap. + buffer[(col >> 3) + + pcr]) & (1 << (~col & 0x07))) ? GD_NUMCOLORS : 0; + } else { + return "Unsupported ft_pixel_mode"; + } + if (tc_key.pixel == 0) /* if background */ + continue; + + x = pen_x + col; + + /* clip if out of bounds */ + if (x > im->cx2 || x < im->cx1) + continue; + /* get pixel location in gd buffer */ + pixel = &im->pixels[y][x]; + if (tc_key.pixel == GD_NUMCOLORS) { + /* use fg color directly. gd 2.0.2: watch out for + negative indexes (thanks to David Marwood). */ + *pixel = (fg < 0) ? -fg : fg; + } else { + /* find antialised color */ + + tc_key.bgcolor = *pixel; + tc_elem = (tweencolor_t *) gdCacheGet (tc_cache, &tc_key); + if (!tc_elem) return tc_cache->error; + *pixel = tc_elem->tweencolor; + } + } + } + return (char *) NULL; +} + +BGD_DECLARE(void) gdFreeFontCache () +{ + gdFontCacheShutdown (); +} + +BGD_DECLARE(void) gdFontCacheShutdown () +{ + if (fontCache) { + gdMutexLock(gdFontCacheMutex); + gdCacheDelete (fontCache); + /* 2.0.16: Gustavo Scotti: make sure we don't free this twice */ + fontCache = 0; + gdMutexUnlock(gdFontCacheMutex); + gdMutexShutdown (gdFontCacheMutex); + FT_Done_FreeType (library); + } +} + +/********************************************************************/ +/* gdImageStringFT - render a utf8 string onto a gd image */ + +BGD_DECLARE(char *) gdImageStringFT (gdImage * im, int *brect, int fg, char *fontlist, + double ptsize, double angle, int x, int y, char *string) +{ + return gdImageStringFTEx (im, brect, fg, fontlist, + ptsize, angle, x, y, string, 0); +} + +BGD_DECLARE(int) gdFontCacheSetup (void) +{ + if (fontCache) { + /* Already set up */ + return 0; + } + gdMutexSetup (gdFontCacheMutex); + if (FT_Init_FreeType (&library)) { + gdMutexShutdown (gdFontCacheMutex); + return -1; + } + fontCache = gdCacheCreate (FONTCACHESIZE, fontTest, fontFetch, fontRelease); + if (!fontCache) { + return -2; + } + return 0; +} + +/* + Function: gdImageStringFTEx + + gdImageStringFTEx extends the capabilities of gdImageStringFT by + providing a way to pass additional parameters. + + If the strex parameter is not null, it must point to a + gdFTStringExtra structure. As of gd 2.0.5, this structure is defined + as follows: + + > typedef struct { + > // logical OR of gdFTEX_ values + > int flags; + > + > // fine tune line spacing for '\n' + > double linespacing; + > + > // Preferred character mapping + > int charmap; + > + > // Rendering resolution + > int hdpi; + > int vdpi; + > char *xshow; + > char *fontpath; + > } gdFTStringExtra, *gdFTStringExtraPtr; + + To output multiline text with a specific line spacing, include + gdFTEX_LINESPACE in the setting of flags: + + > flags |= gdFTEX_LINESPACE; + + And also set linespacing to the desired spacing, expressed as a + multiple of the font height. Thus a line spacing of 1.0 is the + minimum to guarantee that lines of text do not collide. + + If gdFTEX_LINESPACE is not present, or strex is null, or + gdImageStringFT is called, linespacing defaults to 1.05. + + To specify a preference for Unicode, Shift_JIS Big5 character + encoding, set or To output multiline text with a specific line + spacing, include gdFTEX_CHARMAP in the setting of flags: + + > flags |= gdFTEX_CHARMAP; + + And set charmap to the desired value, which can be any of + gdFTEX_Unicode, gdFTEX_Shift_JIS, gdFTEX_Big5, or + gdFTEX_Adobe_Custom. If you do not specify a preference, Unicode + will be tried first. If the preferred character mapping is not found + in the font, other character mappings are attempted. + + GD operates on the assumption that the output image will be rendered + to a computer screen. By default, gd passes a resolution of 96 dpi + to the freetype text rendering engine. This influences the "hinting" + decisions made by the renderer. To specify a different resolution, + set hdpi and vdpi accordingly (in dots per inch) and add + gdFTEX_RESOLUTION to flags: + + > flags | gdFTEX_RESOLUTION; + + GD 2.0.29 and later will normally attempt to apply kerning tables, + if fontconfig is available, to adjust the relative positions of + consecutive characters more ideally for that pair of + characters. This can be turn off by specifying the + gdFTEX_DISABLE_KERNING flag: + + > flags | gdFTEX_DISABLE_KERNING; + + GD 2.0.29 and later can return a vector of individual character + position advances, occasionally useful in applications that must + know exactly where each character begins. This is returned in the + xshow element of the gdFTStringExtra structure if the gdFTEX_XSHOW + flag is set: + + > flags | gdFTEX_XSHOW; + + The caller is responsible for calling gdFree() on the xshow element + after the call if gdFTEX_XSHOW is set. + + GD 2.0.29 and later can also return the path to the actual font file + used if the gdFTEX_RETURNFONTPATHNAME flag is set. This is useful + because GD 2.0.29 and above are capable of selecting a font + automatically based on a fontconfig font pattern when fontconfig is + available. This information is returned in the fontpath element of + the gdFTStringExtra structure. + + > flags | gdFTEX_RETURNFONTPATHNAME; + + The caller is responsible for calling gdFree() on the fontpath + element after the call if gdFTEX_RETURNFONTPATHNAME is set. + + GD 2.0.29 and later can use fontconfig to resolve font names, + including fontconfig patterns, if the gdFTEX_FONTCONFIG flag is + set. As a convenience, this behavior can be made the default by + calling gdFTUseFontConfig with a nonzero value. In that situation it + is not necessary to set the gdFTEX_FONTCONFIG flag on every call; + however explicit font path names can still be used if the + gdFTEX_FONTPATHNAME flag is set: + + > flags | gdFTEX_FONTPATHNAME; + + Unless gdFTUseFontConfig has been called with a nonzero value, GD + 2.0.29 and later will still expect the fontlist argument to the + freetype text output functions to be a font file name or list + thereof as in previous versions. If you do not wish to make + fontconfig the default, it is still possible to force the use of + fontconfig for a single call to the freetype text output functions + by setting the gdFTEX_FONTCONFIG flag: + + > flags | gdFTEX_FONTCONFIG; + + GD 2.0.29 and above can use fontconfig to resolve font names, + including fontconfig patterns, if the gdFTEX_FONTCONFIG flag is + set. As a convenience, this behavior can be made the default by + calling gdFTUseFontConfig with a nonzero value. In that situation it + is not necessary to set the gdFTEX_FONTCONFIG flag on every call; + however explicit font path names can still be used if the + gdFTEX_FONTPATHNAME flag is set: + + > flags | gdFTEX_FONTPATHNAME; + + For more information, see <gdImageStringFT>. +*/ + +/* the platform-independent resolution used for size and position calculations */ +/* the size of the error introduced by rounding is affected by this number */ +#define METRIC_RES 300 + +BGD_DECLARE(char *) gdImageStringFTEx (gdImage * im, int *brect, int fg, char *fontlist, + double ptsize, double angle, int x, int y, char *string, + gdFTStringExtraPtr strex) +{ + FT_Matrix matrix; + FT_Vector penf, oldpenf, delta, total_min = {0,0}, total_max = {0,0}, glyph_min, glyph_max; + FT_Face face; + FT_CharMap charmap = NULL; + FT_Glyph image; + FT_GlyphSlot slot; + FT_Error err; + FT_UInt glyph_index, previous; + double sin_a = sin (angle); + double cos_a = cos (angle); + int len, i, ch; + font_t *font; + fontkey_t fontkey; + char *next; + char *tmpstr = 0; + int render = (im && (im->trueColor || (fg <= 255 && fg >= -255))); + FT_BitmapGlyph bm; + /* 2.0.13: Bob Ostermann: don't force autohint, that's just for testing + freetype and doesn't look as good */ + int render_mode = FT_LOAD_DEFAULT; + int encoding, encodingfound; + /* Now tuneable thanks to Wez Furlong */ + double linespace = LINESPACE; + /* 2.0.6: put this declaration with the other declarations! */ + /* + * make a new tweenColorCache on every call + * because caching colormappings between calls + * is not safe. If the im-pointer points to a + * brand new image, the cache gives out bogus + * colorindexes. -- 27.06.2001 <krisku@arrak.fi> + */ + gdCache_head_t *tc_cache; + /* Tuneable horizontal and vertical resolution in dots per inch */ + int hdpi, vdpi, horiAdvance, xshow_alloc = 0, xshow_pos = 0; + FT_Size platform_specific, platform_independent; + + if (strex) { + if ((strex->flags & gdFTEX_LINESPACE) == gdFTEX_LINESPACE) { + linespace = strex->linespacing; + } + } + tc_cache = gdCacheCreate (TWEENCOLORCACHESIZE, + tweenColorTest, tweenColorFetch, + tweenColorRelease); + + /***** initialize font library and font cache on first call ******/ + if (!fontCache) { + if (gdFontCacheSetup () != 0) { + gdCacheDelete (tc_cache); + return "Failure to initialize font library"; + } + } + /*****/ + gdMutexLock (gdFontCacheMutex); + /* get the font (via font cache) */ + fontkey.fontlist = fontlist; + if (strex) + fontkey.flags = strex->flags & (gdFTEX_FONTPATHNAME | + gdFTEX_FONTCONFIG); + else + fontkey.flags = 0; + fontkey.library = &library; + font = (font_t *) gdCacheGet (fontCache, &fontkey); + if (!font) { + gdCacheDelete (tc_cache); + gdMutexUnlock (gdFontCacheMutex); + return fontCache->error; + } + face = font->face; /* shortcut */ + slot = face->glyph; /* shortcut */ + + if (brect) { + total_min.x = total_min.y = 0; + total_max.x = total_max.y = 0; + } + + /* + * Added hdpi and vdpi to support images at non-screen resolutions, i.e. 300 dpi TIFF, + * or 100h x 50v dpi FAX format. 2.0.23. + * 2004/02/27 Mark Shackelford, mark.shackelford@acs-inc.com + */ + hdpi = GD_RESOLUTION; + vdpi = GD_RESOLUTION; + encoding = gdFTEX_Unicode; + if (strex) { + if (strex->flags & gdFTEX_RESOLUTION) { + hdpi = strex->hdpi; + vdpi = strex->vdpi; + } + if (strex->flags & gdFTEX_XSHOW) { + strex->xshow = NULL; + } + /* 2.0.12: allow explicit specification of the preferred map; + but we still fall back if it is not available. */ + if (strex->flags & gdFTEX_CHARMAP) { + encoding = strex->charmap; + } + /* 2.0.29: we can return the font path if desired */ + if (strex->flags & gdFTEX_RETURNFONTPATHNAME) { + const unsigned int fontpath_len = strlen(font->fontpath); + + strex->fontpath = (char *) gdMalloc(fontpath_len + 1); + if (strex->fontpath == NULL) { + gdCacheDelete(tc_cache); + gdMutexUnlock(gdFontCacheMutex); + return "could not alloc full list of fonts"; + } + strncpy(strex->fontpath, font->fontpath, fontpath_len); + strex->fontpath[fontpath_len] = 0; + } + } + + matrix.xx = (FT_Fixed) (cos_a * (1 << 16)); + matrix.yx = (FT_Fixed) (sin_a * (1 << 16)); + matrix.xy = -matrix.yx; + matrix.yy = matrix.xx; + + /* set rotation transform */ + FT_Set_Transform (face, &matrix, NULL); + + FT_New_Size (face, &platform_independent); + FT_Activate_Size (platform_independent); + if (FT_Set_Char_Size (face, 0, (FT_F26Dot6)(ptsize*64), METRIC_RES, METRIC_RES)) { + gdCacheDelete (tc_cache); + gdMutexUnlock (gdFontCacheMutex); + return "Could not set character size"; + } + + if (render) { + FT_New_Size (face, &platform_specific); + FT_Activate_Size (platform_specific); + if (FT_Set_Char_Size (face, 0, (FT_F26Dot6)(ptsize*64), hdpi, vdpi)) { + gdCacheDelete (tc_cache); + gdMutexUnlock (gdFontCacheMutex); + return "Could not set character size"; + } + } + + if (fg < 0) + render_mode |= FT_LOAD_MONOCHROME; + + /* find requested charmap */ + encodingfound = 0; + for (i = 0; i < face->num_charmaps; i++) { + charmap = face->charmaps[i]; + +#if ((defined(FREETYPE_MAJOR)) && (((FREETYPE_MAJOR == 2) && (((FREETYPE_MINOR == 1) && (FREETYPE_PATCH >= 3)) || (FREETYPE_MINOR > 1))) || (FREETYPE_MAJOR > 2))) + if (encoding == gdFTEX_Unicode) { + if (charmap->encoding == FT_ENCODING_MS_SYMBOL + || charmap->encoding == FT_ENCODING_UNICODE + || charmap->encoding == FT_ENCODING_ADOBE_CUSTOM + || charmap->encoding == FT_ENCODING_ADOBE_STANDARD) { + encodingfound++; + break; + } + } else if (encoding == gdFTEX_Adobe_Custom) { + if (charmap->encoding == FT_ENCODING_ADOBE_CUSTOM) { + encodingfound++; + break; + } + } else if (encoding == gdFTEX_Big5) { + /* renamed sometime after freetype-2.1.4 */ +#ifndef FT_ENCODING_BIG5 +#define FT_ENCODING_BIG5 FT_ENCODING_MS_BIG5 +#endif + if (charmap->encoding == FT_ENCODING_BIG5) { + encodingfound++; + break; + } + } else if (encoding == gdFTEX_Shift_JIS) { + /* renamed sometime after freetype-2.1.4 */ +#ifndef FT_ENCODING_SJIS +#define FT_ENCODING_SJIS FT_ENCODING_MS_SJIS +#endif + if (charmap->encoding == FT_ENCODING_SJIS) { + encodingfound++; + break; + } + } +#else + if (encoding == gdFTEX_Unicode) { + if ((charmap->platform_id = 3 && charmap->encoding_id == 1) /* Windows Unicode */ + || (charmap->platform_id == 3 && charmap->encoding_id == 0) /* Windows Symbol */ + || (charmap->platform_id == 2 && charmap->encoding_id == 1) /* ISO Unicode */ + || (charmap->platform_id == 0)) { /* Apple Unicode */ + encodingfound++; + break; + } + } else if (encoding == gdFTEX_Big5) { + if (charmap->platform_id == 3 && charmap->encoding_id == 4) { /* Windows Big5 */ + encodingfound++; + break; + } + } else if (encoding == gdFTEX_Shift_JIS) { + if (charmap->platform_id == 3 && charmap->encoding_id == 2) { /* Windows Sjis */ + encodingfound++; + break; + } + } +#endif + } + if (encodingfound) { + FT_Set_Charmap(face, charmap); + } else { + /* No character set found! */ + gdCacheDelete (tc_cache); + gdMutexUnlock (gdFontCacheMutex); + return "No character set found"; + } + +#ifndef JISX0208 + if (encoding == gdFTEX_Shift_JIS) { +#endif + if ((tmpstr = (char *) gdMalloc (BUFSIZ))) { + any2eucjp (tmpstr, string, BUFSIZ); + next = tmpstr; + } else { + next = string; + } +#ifndef JISX0208 + } else { + next = string; + } +#endif + + oldpenf.x = oldpenf.y = 0; /* for postscript xshow operator */ + penf.x = penf.y = 0; /* running position of non-rotated glyphs */ + previous = 0; /* index of previous glyph for kerning calculations */ + for (i=0; *next; i++) { + FT_Activate_Size (platform_independent); + + ch = *next; + + /* carriage returns */ + if (ch == '\r') { + penf.x = 0; + previous = 0; /* clear kerning flag */ + next++; + continue; + } + /* newlines */ + if (ch == '\n') { + /* 2.0.13: reset penf.x. Christopher J. Grayce */ + penf.x = 0; + penf.y += linespace * ptsize * 64 * METRIC_RES / 72; + penf.y &= ~63; /* round down to 1/METRIC_RES */ + previous = 0; /* clear kerning flag */ + next++; + continue; + } + + + switch (encoding) { + case gdFTEX_Unicode: { + /* use UTF-8 mapping from ASCII */ + len = gdTcl_UtfToUniChar (next, &ch); + /* EAM DEBUG */ + /* TBB: get this exactly right: 2.1.3 *or better*, all possible cases. */ + /* 2.0.24: David R. Morrison: use the more complete ifdef here. */ +#if ((defined(FREETYPE_MAJOR)) && (((FREETYPE_MAJOR == 2) && (((FREETYPE_MINOR == 1) && (FREETYPE_PATCH >= 3)) || (FREETYPE_MINOR > 1))) || (FREETYPE_MAJOR > 2))) + if (charmap->encoding == FT_ENCODING_MS_SYMBOL) +#else + if (charmap->platform_id == 3 && charmap->encoding_id == 0) +#endif /* Freetype 2.1 or better */ + { + /* I do not know the significance of the constant 0xf000. */ + /* It was determined by inspection of the character codes */ + /* stored in Microsoft font symbol.ttf */ + ch |= 0xf000; + } + /* EAM DEBUG */ + next += len; + } + break; + case gdFTEX_Shift_JIS: { + unsigned char c; + int jiscode; + c = *next; + if (0xA1 <= c && c <= 0xFE) { + next++; + jiscode = 0x100 * (c & 0x7F) + ((*next) & 0x7F); + + ch = (jiscode >> 8) & 0xFF; + jiscode &= 0xFF; + + if (ch & 1) + jiscode += 0x40 - 0x21; + else + jiscode += 0x9E - 0x21; + + if (jiscode >= 0x7F) + jiscode++; + ch = (ch - 0x21) / 2 + 0x81; + if (ch >= 0xA0) + ch += 0x40; + + ch = (ch << 8) + jiscode; + } else { + ch = c & 0xFF; /* don't extend sign */ + } + if (*next) next++; + } + break; + case gdFTEX_Big5: { + /* + * Big 5 mapping: + * use "JIS-8 half-width katakana" coding from 8-bit characters. Ref: + * ftp://ftp.ora.com/pub/examples/nutshell/ujip/doc/japan.inf-032092.sjs + */ + ch = (*next) & 0xFF; /* don't extend sign */ + next++; + if (ch >= 161 /* first code of JIS-8 pair */ + && *next) { + /* don't advance past '\0' */ + /* TBB: Fix from Kwok Wah On: & 255 needed */ + ch = (ch * 256) + ((*next) & 255); + next++; + } + } + break; + + case gdFTEX_Adobe_Custom: + default: + ch &= 0xFF; + next++; + break; + } + + /* Convert character code to glyph index */ + glyph_index = FT_Get_Char_Index (face, ch); + + /* retrieve kerning distance */ + if ( ! (strex && (strex->flags & gdFTEX_DISABLE_KERNING)) + && ! FT_IS_FIXED_WIDTH(face) + && FT_HAS_KERNING(face) + && previous + && glyph_index) + FT_Get_Kerning (face, previous, glyph_index, ft_kerning_default, &delta); + else + delta.x = delta.y = 0; + + penf.x += delta.x; + + /* When we know the position of the second or subsequent character, + save the (kerned) advance from the preceeding character in the + xshow vector */ + if (i && strex && (strex->flags & gdFTEX_XSHOW)) { + /* make sure we have enough allocation for two numbers + so we don't have to recheck for the terminating number */ + if (! xshow_alloc) { + xshow_alloc = 100; + strex->xshow = gdMalloc(xshow_alloc); + if (!strex->xshow) { + if (tmpstr) + gdFree (tmpstr); + gdCacheDelete (tc_cache); + gdMutexUnlock (gdFontCacheMutex); + return "Problem allocating memory"; + } + xshow_pos = 0; + } else if (xshow_pos + 20 > xshow_alloc) { + xshow_alloc += 100; + strex->xshow = gdReallocEx(strex->xshow, xshow_alloc); + if (!strex->xshow) { + if (tmpstr) + gdFree (tmpstr); + gdCacheDelete (tc_cache); + gdMutexUnlock (gdFontCacheMutex); + return "Problem allocating memory"; + } + } + xshow_pos += sprintf(strex->xshow + xshow_pos, "%g ", + (double)(penf.x - oldpenf.x) * hdpi / (64 * METRIC_RES)); + } + oldpenf.x = penf.x; + + /* load glyph image into the slot (erase previous one) */ + err = FT_Load_Glyph (face, glyph_index, render_mode); + if (err) { + if (tmpstr) + gdFree (tmpstr); + gdCacheDelete (tc_cache); + gdMutexUnlock (gdFontCacheMutex); + return "Problem loading glyph"; + } + + horiAdvance = slot->metrics.horiAdvance; + + if (brect) { + /* only if need brect */ + + glyph_min.x = penf.x + slot->metrics.horiBearingX; + glyph_min.y = penf.y - slot->metrics.horiBearingY; + +#if 0 + if (ch == ' ') { /* special case for trailing space */ + glyph_max.x = penf.x + horiAdvance; + } else { + glyph_max.x = glyph_min.x + slot->metrics.width; + } +#else + glyph_max.x = penf.x + horiAdvance; +#endif + glyph_max.y = glyph_min.y + slot->metrics.height; + + if (i==0) { + total_min = glyph_min; + total_max = glyph_max; + } else { + if (glyph_min.x < total_min.x) + total_min.x = glyph_min.x; + if (glyph_min.y < total_min.y) + total_min.y = glyph_min.y; + if (glyph_max.x > total_max.x) + total_max.x = glyph_max.x; + if (glyph_max.y > total_max.y) + total_max.y = glyph_max.y; + } + } + + if (render) { + FT_Activate_Size (platform_specific); + + /* load glyph again into the slot (erase previous one) - this time with scaling */ + err = FT_Load_Glyph (face, glyph_index, render_mode); + if (err) { + if (tmpstr) + gdFree (tmpstr); + gdCacheDelete (tc_cache); + gdMutexUnlock (gdFontCacheMutex); + return "Problem loading glyph"; + } + + /* load and transform glyph image */ + FT_Get_Glyph (slot, &image); + + if (image->format != ft_glyph_format_bitmap) { + err = FT_Glyph_To_Bitmap (&image, ft_render_mode_normal, 0, 1); + if (err) { + FT_Done_Glyph(image); + if (tmpstr) + gdFree (tmpstr); + gdCacheDelete (tc_cache); + gdMutexUnlock (gdFontCacheMutex); + return "Problem rendering glyph"; + } + } + + /* now, draw to our target surface */ + bm = (FT_BitmapGlyph) image; + /* position rounded down to nearest pixel at current dpi + (the estimate was rounded up to next 1/METRIC_RES, so this should fit) */ + gdft_draw_bitmap (tc_cache, im, fg, bm->bitmap, + (int)(x + (penf.x * cos_a + penf.y * sin_a)*hdpi/(METRIC_RES*64) + bm->left), + (int)(y - (penf.x * sin_a - penf.y * cos_a)*vdpi/(METRIC_RES*64) - bm->top)); + + FT_Done_Glyph (image); + } + + /* record current glyph index for kerning */ + previous = glyph_index; + + penf.x += horiAdvance; + } + + /* Save the (unkerned) advance from the last character in the xshow vector */ + if (strex && (strex->flags & gdFTEX_XSHOW) && strex->xshow) { + sprintf(strex->xshow + xshow_pos, "%g", + (double)(penf.x - oldpenf.x) * hdpi / (64 * METRIC_RES) ); + } + + if (brect) { + /* only if need brect */ + double scalex = (double)hdpi / (64 * METRIC_RES); + double scaley = (double)vdpi / (64 * METRIC_RES); + + /* increase by 1 pixel to allow for rounding */ + total_min.x -= METRIC_RES; + total_min.y -= METRIC_RES; + total_max.x += METRIC_RES; + total_max.y += METRIC_RES; + + /* rotate bounding rectangle, scale and round to int pixels, and translate */ + brect[0] = x + (total_min.x * cos_a + total_max.y * sin_a)*scalex; + brect[1] = y - (total_min.x * sin_a - total_max.y * cos_a)*scaley; + brect[2] = x + (total_max.x * cos_a + total_max.y * sin_a)*scalex; + brect[3] = y - (total_max.x * sin_a - total_max.y * cos_a)*scaley; + brect[4] = x + (total_max.x * cos_a + total_min.y * sin_a)*scalex; + brect[5] = y - (total_max.x * sin_a - total_min.y * cos_a)*scaley; + brect[6] = x + (total_min.x * cos_a + total_min.y * sin_a)*scalex; + brect[7] = y - (total_min.x * sin_a - total_min.y * cos_a)*scaley; + } + + FT_Done_Size (platform_independent); + if (render) + FT_Done_Size (platform_specific); + + if (tmpstr) + gdFree (tmpstr); + gdCacheDelete (tc_cache); + gdMutexUnlock (gdFontCacheMutex); + return (char *) NULL; +} + +#endif /* HAVE_LIBFREETYPE */ + +#ifdef HAVE_LIBFONTCONFIG +/* Code to find font path, with special mapping for Postscript font names. + * + * Dag Lem <dag@nimrod.no> + */ + +#include <fontconfig/fontconfig.h> + +/* #define NO_POSTSCRIPT_ALIAS 1 */ +#ifndef NO_POSTSCRIPT_ALIAS +typedef struct _PostscriptAlias { + char* name; + char* family; + char* style; +} PostscriptAlias; + +/* This table maps standard Postscript font names to URW Type 1 fonts. + The mapping is converted from Ghostscript (Fontmap.GS) + for use with fontconfig. */ +static PostscriptAlias postscript_alias[] = { + { "AvantGarde-Book", "URW Gothic L", "Book" }, + { "AvantGarde-BookOblique", "URW Gothic L", "Book Oblique" }, + { "AvantGarde-Demi", "URW Gothic L", "Demi" }, + { "AvantGarde-DemiOblique", "URW Gothic L", "Demi Oblique" }, + + { "Bookman-Demi", "URW Bookman L", "Demi Bold" }, + { "Bookman-DemiItalic", "URW Bookman L", "Demi Bold Italic" }, + { "Bookman-Light", "URW Bookman L", "Light" }, + { "Bookman-LightItalic", "URW Bookman L", "Light Italic" }, + + { "Courier", "Nimbus Mono L", "Regular" }, + { "Courier-Oblique", "Nimbus Mono L", "Regular Oblique" }, + { "Courier-Bold", "Nimbus Mono L", "Bold" }, + { "Courier-BoldOblique", "Nimbus Mono L", "Bold Oblique" }, + + { "Helvetica", "Nimbus Sans L", "Regular" }, + { "Helvetica-Oblique", "Nimbus Sans L", "Regular Italic" }, + { "Helvetica-Bold", "Nimbus Sans L", "Bold" }, + { "Helvetica-BoldOblique", "Nimbus Sans L", "Bold Italic" }, + + { "Helvetica-Narrow", "Nimbus Sans L", "Regular Condensed" }, + { "Helvetica-Narrow-Oblique", "Nimbus Sans L", "Regular Condensed Italic" }, + { "Helvetica-Narrow-Bold", "Nimbus Sans L", "Bold Condensed" }, + { "Helvetica-Narrow-BoldOblique", "Nimbus Sans L", "Bold Condensed Italic" }, + + { "NewCenturySchlbk-Roman", "Century Schoolbook L", "Roman" }, + { "NewCenturySchlbk-Italic", "Century Schoolbook L", "Italic" }, + { "NewCenturySchlbk-Bold", "Century Schoolbook L", "Bold" }, + { "NewCenturySchlbk-BoldItalic", "Century Schoolbook L", "Bold Italic" }, + + { "Palatino-Roman", "URW Palladio L", "Roman" }, + { "Palatino-Italic", "URW Palladio L", "Italic" }, + { "Palatino-Bold", "URW Palladio L", "Bold" }, + { "Palatino-BoldItalic", "URW Palladio L", "Bold Italic" }, + + { "Symbol", "Standard Symbols L", "Regular" }, + + { "Times-Roman", "Nimbus Roman No9 L", "Regular" }, + { "Times-Italic", "Nimbus Roman No9 L", "Regular Italic" }, + { "Times-Bold", "Nimbus Roman No9 L", "Medium" }, + { "Times-BoldItalic", "Nimbus Roman No9 L", "Medium Italic" }, + + { "ZapfChancery-MediumItalic", "URW Chancery L", "Medium Italic" }, + + { "ZapfDingbats", "Dingbats", "" }, +}; +#endif + + +static FcPattern* find_font(FcPattern* pattern) +{ + FcResult result; + + FcConfigSubstitute(0, pattern, FcMatchPattern); + FcConfigSubstitute(0, pattern, FcMatchFont); + FcDefaultSubstitute(pattern); + + return FcFontMatch(0, pattern, &result); +} + + +#ifndef NO_POSTSCRIPT_ALIAS +static char* find_postscript_font(FcPattern **fontpattern, char* fontname) +{ + FcPattern* font = NULL; + size_t i; + + *fontpattern = NULL; + for (i = 0; i < sizeof(postscript_alias)/sizeof(*postscript_alias); i++) { + if (strcmp(fontname, postscript_alias[i].name) == 0) { + FcChar8* family; + + FcPattern* pattern = + FcPatternBuild(0, + FC_FAMILY, FcTypeString, postscript_alias[i].family, + FC_STYLE, FcTypeString, postscript_alias[i].style, + (char*)0); + font = find_font(pattern); + FcPatternDestroy(pattern); + + if (!font) + return "fontconfig: Couldn't find font."; + if (FcPatternGetString(font, FC_FAMILY, 0, &family) != FcResultMatch) { + FcPatternDestroy(font); + return "fontconfig: Couldn't retrieve font family name."; + } + + /* Check whether we got the font family we wanted. */ + if (strcmp((const char *)family, postscript_alias[i].family) != 0) { + FcPatternDestroy(font); + return "fontconfig: Didn't find expected font family. Perhaps URW Type 1 fonts need installing?"; + } + break; + } + } + + *fontpattern = font; + return NULL; +} +#endif + +static char * font_pattern(char **fontpath, char *fontpattern) +{ + FcPattern* font = NULL; + FcChar8* file; + FcPattern* pattern; +#ifndef NO_POSTSCRIPT_ALIAS + char *error; +#endif + + *fontpath = NULL; +#ifndef NO_POSTSCRIPT_ALIAS + error = find_postscript_font(&font, fontpattern); + + if (!font) { + if (error) + return error; +#endif + pattern = FcNameParse((const FcChar8 *)fontpattern); + font = find_font(pattern); + FcPatternDestroy(pattern); +#ifndef NO_POSTSCRIPT_ALIAS + } +#endif + + if (!font) + return "fontconfig: Couldn't find font."; + if (FcPatternGetString(font, FC_FILE, 0, &file) != FcResultMatch) { + FcPatternDestroy(font); + return "fontconfig: Couldn't retrieve font file name."; + } else { + const unsigned int file_len = strlen((const char *)file); + + *fontpath = (char *) gdMalloc(file_len + 1); + if (*fontpath == NULL) { + return "could not alloc font path"; + } + strncpy(*fontpath, (const char *)file, file_len); + (*fontpath)[file_len] = 0; + } + FcPatternDestroy(font); + + return NULL; +} + +#endif /* HAVE_LIBFONTCONFIG */ + +/* Look up font using font names as file names. */ +static char * font_path(char **fontpath, char *name_list) +{ + int font_found = 0; + char *fontsearchpath, *fontlist; + char *fullname = NULL; + char *name, *dir; + char *path; + char *strtok_ptr = NULL; + const unsigned int name_list_len = strlen(name_list); + + /* + * Search the pathlist for any of a list of font names. + */ + *fontpath = NULL; + fontsearchpath = getenv ("GDFONTPATH"); +#ifdef _WIN32 + if (!fontsearchpath) { + char *ffptr = getenv ("SYSTEMROOT"); + if (ffptr) { + fontsearchpath = malloc (strlen(ffptr) + strlen("\\fonts") + 1); + strcpy(fontsearchpath, ffptr); + strcat(fontsearchpath, "\\fonts"); + } + } +#endif + if (!fontsearchpath) + fontsearchpath = DEFAULT_FONTPATH; + path = (char *) gdMalloc(sizeof(char) * strlen(fontsearchpath) + 1); + if( path == NULL ) { + return "could not alloc full list of fonts"; + } + path[0] = 0; + + fontlist = (char *) gdMalloc(name_list_len + 1); + if (fontlist == NULL) { + gdFree(path); + return "could not alloc full list of fonts"; + } + strncpy(fontlist, name_list, name_list_len); + fontlist[name_list_len] = 0; + + /* + * Must use gd_strtok_r else pointer corrupted by strtok in nested loop. + */ + for (name = gd_strtok_r (fontlist, LISTSEPARATOR, &strtok_ptr); name; + name = gd_strtok_r (0, LISTSEPARATOR, &strtok_ptr)) { + char *path_ptr = NULL; + + /* make a fresh copy each time - strtok corrupts it. */ + sprintf (path, "%s", fontsearchpath); + /* + * Allocate an oversized buffer that is guaranteed to be + * big enough for all paths to be tested. + */ + /* 2.0.22: Thorben Kundinger: +8 is needed, not +6. */ + fullname = gdReallocEx(fullname, + strlen (fontsearchpath) + strlen (name) + 8); + if (!fullname) { + gdFree(fontlist); + gdFree(path); + return "could not alloc full path of font"; + } + /* if name is an absolute or relative pathname then test directly */ +#ifdef NETWARE + /* netware uses the format "volume:/path" or the standard "/path" */ + if (name[0] != 0 && (strstr(name, ":/") || name[0] == '/')) +#else + if (strchr (name, '/') + || (name[0] != 0 && name[1] == ':' + && (name[2] == '/' || name[2] == '\\'))) +#endif + { + sprintf (fullname, "%s", name); + if (access (fullname, R_OK) == 0) { + font_found++; + break; + } + } + for (dir = gd_strtok_r (path, PATHSEPARATOR, &path_ptr); dir; + dir = gd_strtok_r (0, PATHSEPARATOR, &path_ptr)) { + if (strchr (name, '.')) { + sprintf (fullname, "%s/%s", dir, name); + if (access (fullname, R_OK) == 0) { + font_found++; + break; + } else { + continue; + } + } + sprintf (fullname, "%s/%s.ttf", dir, name); + if (access (fullname, R_OK) == 0) { + font_found++; + break; + } + sprintf (fullname, "%s/%s.pfa", dir, name); + if (access (fullname, R_OK) == 0) { + font_found++; + break; + } + sprintf (fullname, "%s/%s.pfb", dir, name); + if (access (fullname, R_OK) == 0) { + font_found++; + break; + } + sprintf (fullname, "%s/%s.dfont", dir, name); + if (access (fullname, R_OK) == 0) { + font_found++; + break; + } + } + + if (font_found) + break; + } + gdFree (path); + if (fontlist != NULL) { + gdFree (fontlist); + fontlist = NULL; + } + if (!font_found) { + gdFree (fullname); + return "Could not find/open font"; + } + + *fontpath = fullname; + return NULL; +} + +BGD_DECLARE(int) gdFTUseFontConfig(int flag) +{ +#ifdef HAVE_LIBFONTCONFIG + fontConfigFlag = flag; + return 1; +#else + (void)flag; + return 0; +#endif /* HAVE_LIBFONTCONFIG */ +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdfx.c b/Build/source/libs/gd/libgd-2.1.1/src/gdfx.c new file mode 100644 index 00000000000..13b32fe1c06 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdfx.c @@ -0,0 +1,465 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif /* HAVE_CONFIG_H */ + +#include "gd.h" +#include "gd_errors.h" +#include <math.h> + +/* In tests this is sufficient to prevent obvious artifacts */ +#define MAG 4 + +#define PI 3.141592 +#define DEG2RAD(x) ((x)*PI/180.) + +#define MAX(x,y) ((x) > (y) ? (x) : (y)) +#define MIN(x,y) ((x) < (y) ? (x) : (y)) + +#define MAX4(x,y,z,w) \ + ((MAX((x),(y))) > (MAX((z),(w))) ? (MAX((x),(y))) : (MAX((z),(w)))) +#define MIN4(x,y,z,w) \ + ((MIN((x),(y))) < (MIN((z),(w))) ? (MIN((x),(y))) : (MIN((z),(w)))) + +#define MAXX(x) MAX4(x[0],x[2],x[4],x[6]) +#define MINX(x) MIN4(x[0],x[2],x[4],x[6]) +#define MAXY(x) MAX4(x[1],x[3],x[5],x[7]) +#define MINY(x) MIN4(x[1],x[3],x[5],x[7]) + +BGD_DECLARE(char *) +gdImageStringFTCircle (gdImagePtr im, + int cx, + int cy, + double radius, + double textRadius, + double fillPortion, + char *font, + double points, char *top, char *bottom, int fgcolor) +{ + char *err; + int w; + int brect[8]; + int sx1, sx2, sy1, sy2, sx, sy; + int x, y; + int fr, fg, fb, fa; + int ox, oy; + double prop; + gdImagePtr im1; + gdImagePtr im2; + gdImagePtr im3; + /* obtain brect so that we can size the image */ + err = gdImageStringFT ((gdImagePtr) NULL, + &brect[0], 0, font, points * MAG, 0, 0, 0, bottom); + if (err) { + return err; + } + sx1 = MAXX (brect) - MINX (brect) + 6; + sy1 = MAXY (brect) - MINY (brect) + 6; + err = gdImageStringFT ((gdImagePtr) NULL, + &brect[0], 0, font, points * MAG, 0, 0, 0, top); + if (err) { + return err; + } + sx2 = MAXX (brect) - MINX (brect) + 6; + sy2 = MAXY (brect) - MINY (brect) + 6; + /* Pad by 4 pixels to allow for slight errors + observed in the bounding box returned by freetype */ + if (sx1 > sx2) { + sx = sx1 * 2 + 4; + } else { + sx = sx2 * 2 + 4; + } + if (sy1 > sy2) { + sy = sy1; + } else { + sy = sy2; + } + im1 = gdImageCreateTrueColor (sx, sy); + if (!im1) { + return "could not create first image"; + } + err = gdImageStringFT (im1, 0, gdTrueColor (255, 255, 255), + font, points * MAG, + 0, ((sx / 2) - sx1) / 2, points * MAG, bottom); + if (err) { + gdImageDestroy (im1); + return err; + } + /* We don't know the descent, which would be needed to do this + with the angle parameter. Instead, implement a simple + flip operation ourselves. */ + err = gdImageStringFT (im1, 0, gdTrueColor (255, 255, 255), + font, points * MAG, + 0, sx / 2 + ((sx / 2) - sx2) / 2, points * MAG, top); + if (err) { + gdImageDestroy (im1); + return err; + } + /* Flip in place is tricky, be careful not to double-swap things */ + if (sy & 1) { + for (y = 0; (y <= (sy / 2)); y++) { + int xlimit = sx - 2; + if (y == (sy / 2)) { + /* If there is a "middle" row, be careful + not to swap twice! */ + xlimit -= (sx / 4); + } + for (x = (sx / 2) + 2; (x < xlimit); x++) { + int t; + int ox = sx - x + (sx / 2) - 1; + int oy = sy - y - 1; + t = im1->tpixels[oy][ox]; + im1->tpixels[oy][ox] = im1->tpixels[y][x]; + im1->tpixels[y][x] = t; + } + } + } else { + for (y = 0; (y < (sy / 2)); y++) { + int xlimit = sx - 2; + for (x = (sx / 2) + 2; (x < xlimit); x++) { + int t; + int ox = sx - x + (sx / 2) - 1; + int oy = sy - y - 1; + t = im1->tpixels[oy][ox]; + im1->tpixels[oy][ox] = im1->tpixels[y][x]; + im1->tpixels[y][x] = t; + } + } + } +#if STEP_PNGS + { + FILE *out = fopen ("gdfx1.png", "wb"); + gdImagePng (im1, out); + fclose (out); + } +#endif /* STEP_PNGS */ + /* Resample taller; the exact proportions of the text depend on the + ratio of textRadius to radius, and the value of fillPortion */ + if (sx > sy * 10) { + w = sx; + } else { + w = sy * 10; + } + im2 = gdImageCreateTrueColor (w, w); + if (!im2) { + gdImageDestroy (im1); + return "could not create resampled image"; + } + prop = textRadius / radius; + gdImageCopyResampled (im2, im1, + gdImageSX (im2) * (1.0 - fillPortion) / 4, + sy * 10 * (1.0 - prop), + 0, 0, + gdImageSX (im2) * fillPortion / 2, sy * 10 * prop, + gdImageSX (im1) / 2, gdImageSY (im1)); + gdImageCopyResampled (im2, im1, + (gdImageSX (im2) / 2) + + gdImageSX (im2) * (1.0 - fillPortion) / 4, + sy * 10 * (1.0 - prop), + gdImageSX (im1) / 2, 0, + gdImageSX (im2) * fillPortion / 2, sy * 10 * prop, + gdImageSX (im1) / 2, gdImageSY (im1)); +#if STEP_PNGS + { + FILE *out = fopen ("gdfx2.png", "wb"); + gdImagePng (im2, out); + fclose (out); + } +#endif /* STEP_PNGS */ + /* Ready to produce a circle */ + im3 = gdImageSquareToCircle (im2, radius); + gdImageDestroy (im1); + gdImageDestroy (im2); + /* Now blend im3 with the destination. Cheat a little. The + source (im3) is white-on-black, so we can use the + red component as a basis for alpha as long as we're + careful to shift off the extra bit and invert + (alpha ranges from 0 to 127 where 0 is OPAQUE). + Also be careful to allow for an alpha component + in the fgcolor parameter itself (gug!) */ + fr = gdTrueColorGetRed (fgcolor); + fg = gdTrueColorGetGreen (fgcolor); + fb = gdTrueColorGetBlue (fgcolor); + fa = gdTrueColorGetAlpha (fgcolor); + ox = cx - (im3->sx / 2); + oy = cy - (im3->sy / 2); + for (y = 0; (y < im3->sy); y++) { + for (x = 0; (x < im3->sx); x++) { + int a = gdTrueColorGetRed (im3->tpixels[y][x]) >> 1; + a *= (127 - fa); + a /= 127; + a = 127 - a; + gdImageSetPixel (im, x + ox, y + oy, + gdTrueColorAlpha (fr, fg, fb, a)); + } + } + gdImageDestroy (im3); + return 0; +} + +#if GDFX_MAIN + +int +main (int argc, char *argv[]) +{ + FILE *in; + FILE *out; + gdImagePtr im; + int radius; + /* Create an image of text on a circle, with an + alpha channel so that we can copy it onto a + background */ + in = fopen ("eleanor.jpg", "rb"); + if (!in) { + im = gdImageCreateTrueColor (300, 300); + } else { + im = gdImageCreateFromJpeg (in); + fclose (in); + } + if (gdImageSX (im) < gdImageSY (im)) { + radius = gdImageSX (im) / 2; + } else { + radius = gdImageSY (im) / 2; + } + gdImageStringFTCircle (im, + gdImageSX (im) / 2, + gdImageSY (im) / 2, + radius, + radius / 2, + 0.8, + "arial", + 24, + "top text", + "bottom text", gdTrueColorAlpha (240, 240, 255, 32)); + out = fopen ("gdfx.png", "wb"); + if (!out) { + gd_error("Can't create gdfx.png\n"); + return 1; + } + gdImagePng (im, out); + fclose (out); + gdImageDestroy (im); + return 0; +} + +#endif /* GDFX_MAIN */ + +/* Note: don't change these */ +#define SUPER 2 +#define SUPERBITS1 1 +#define SUPERBITS2 2 + +BGD_DECLARE(gdImagePtr) +gdImageSquareToCircle (gdImagePtr im, int radius) +{ + int x, y; + double c; + gdImagePtr im2; + if (im->sx != im->sy) { + /* Source image must be square */ + return 0; + } + im2 = gdImageCreateTrueColor (radius * 2, radius * 2); + /* Supersampling for a nicer result */ + c = (im2->sx / 2) * SUPER; + for (y = 0; (y < im2->sy * SUPER); y++) { + for (x = 0; (x < im2->sx * SUPER); x++) { + double rho = sqrt ((x - c) * (x - c) + (y - c) * (y - c)); + int pix; + int cpix; + double theta; + double ox; + double oy; + int red, green, blue, alpha; + if (rho > c) { + continue; + } + theta = atan2 (x - c, y - c) + PI / 2; + if (theta < 0) { + theta += 2 * PI; + } + /* Undo supersampling */ + oy = (rho * im->sx) / (im2->sx * SUPER / 2); + ox = theta * im->sx / (3.141592653 * 2); + pix = gdImageGetPixel (im, ox, oy); + cpix = im2->tpixels[y >> SUPERBITS1][x >> SUPERBITS1]; + red = + (gdImageRed (im, pix) >> SUPERBITS2) + gdTrueColorGetRed (cpix); + green = + (gdImageGreen (im, pix) >> SUPERBITS2) + + gdTrueColorGetGreen (cpix); + blue = + (gdImageBlue (im, pix) >> SUPERBITS2) + gdTrueColorGetBlue (cpix); + alpha = + (gdImageAlpha (im, pix) >> SUPERBITS2) + + gdTrueColorGetAlpha (cpix); + im2->tpixels[y >> SUPERBITS1][x >> SUPERBITS1] = + gdTrueColorAlpha (red, green, blue, alpha); + } + } + /* Restore full dynamic range, 0-63 yields 0-252. Replication of + first 2 bits in last 2 bits has the desired effect. Note + slightly different arithmetic for alpha which is 7-bit. + NOTE: only correct for SUPER == 2 */ + for (y = 0; (y < im2->sy); y++) { + for (x = 0; (x < im2->sx); x++) { + /* Copy first 2 bits to last 2 bits, matching the + dynamic range of the original cheaply */ + int cpix = im2->tpixels[y][x]; + + im2->tpixels[y][x] = gdTrueColorAlpha ((gdTrueColorGetRed (cpix) & + 0xFC) + + ((gdTrueColorGetRed (cpix) & + 0xC0) >> 6), + (gdTrueColorGetGreen (cpix) & + 0xFC) + + ((gdTrueColorGetGreen (cpix) + & 0xC0) >> 6), + (gdTrueColorGetBlue (cpix) & + 0xFC) + + ((gdTrueColorGetBlue (cpix) & + 0xC0) >> 6), + (gdTrueColorGetAlpha (cpix) & + 0x7C) + + ((gdTrueColorGetAlpha (cpix) + & 0x60) >> 6)); + } + } + return im2; +} + +/* 2.0.16: Called by gdImageSharpen to avoid excessive code repetition + Added on 2003-11-19 by + Paul Troughton (paul<dot>troughton<at>ieee<dot>org) + Given filter coefficents and colours of three adjacent pixels, +returns new colour for centre pixel +*/ + +int +gdImageSubSharpen (int pc, int c, int nc, float inner_coeff, float + outer_coeff) +{ + float red, green, blue, alpha; + + red = inner_coeff * gdTrueColorGetRed (c) + outer_coeff * + (gdTrueColorGetRed (pc) + gdTrueColorGetRed (nc)); + green = inner_coeff * gdTrueColorGetGreen (c) + outer_coeff * + (gdTrueColorGetGreen (pc) + gdTrueColorGetGreen (nc)); + blue = inner_coeff * gdTrueColorGetBlue (c) + outer_coeff * + (gdTrueColorGetBlue (pc) + gdTrueColorGetBlue (nc)); + alpha = gdTrueColorGetAlpha (c); + + /* Clamping, as can overshoot bounds in either direction */ + if (red > 255.0f) { + red = 255.0f; + } + if (green > 255.0f) { + green = 255.0f; + } + if (blue > 255.0f) { + blue = 255.0f; + } + if (red < 0.0f) { + red = 0.0f; + } + if (green < 0.0f) { + green = 0.0f; + } + if (blue < 0.0f) { + blue = 0.0f; + } + + return gdTrueColorAlpha ((int) red, (int) green, (int) blue, (int) alpha); +} + +/* + * Sharpen function added on 2003-11-19 + * by Paul Troughton (paul<dot>troughton<at>ieee<dot>org) + * Simple 3x3 convolution kernel + * Makes use of seperability + * Faster, but less flexible, than full-blown unsharp masking + * pct is sharpening percentage, and can be greater than 100 + * Silently does nothing to non-truecolor images + * Silently does nothing for pct<0, as not a useful blurring function + * Leaves transparency/alpha-channel untouched + */ +BGD_DECLARE(void) +gdImageSharpen (gdImagePtr im, int pct) +{ + int x, y; + int sx, sy; + float inner_coeff, outer_coeff; + + sx = im->sx; + sy = im->sy; + + /* Must sum to 1 to avoid overall change in brightness. + * Scaling chosen so that pct=100 gives 1-D filter [-1 6 -1]/4, + * resulting in a 2-D filter [1 -6 1; -6 36 -6; 1 -6 1]/16, + * which gives noticeable, but not excessive, sharpening + */ + + outer_coeff = -pct / 400.0; + inner_coeff = 1 - 2 * outer_coeff; + + /* Don't try to do anything with non-truecolor images, as + pointless, + * nor for pct<=0, as small kernel size leads to nasty + artefacts when blurring + */ + if ((im->trueColor) && (pct > 0)) { + + /* First pass, 1-D convolution column-wise */ + for (x = 0; x < sx; x++) { + + /* pc is colour of previous pixel; c of the + current pixel and nc of the next */ + int pc, c, nc; + + /* Replicate edge pixel at image boundary */ + pc = gdImageGetPixel (im, x, 0); + + /* Stop looping before last pixel to avoid + conditional within loop */ + for (y = 0; y < sy - 1; y++) { + + c = gdImageGetPixel (im, x, y); + + nc = gdImageGetTrueColorPixel (im, x, y + 1); + + /* Update centre pixel to new colour */ + gdImageSetPixel (im, x, y, + gdImageSubSharpen (pc, c, nc, inner_coeff, + outer_coeff)); + + /* Save original colour of current + pixel for next time round */ + pc = c; + } + + /* Deal with last pixel, replicating current + pixel at image boundary */ + c = gdImageGetPixel (im, x, y); + gdImageSetPixel (im, x, y, gdImageSubSharpen + (pc, c, c, inner_coeff, outer_coeff)); + } + + /* Second pass, 1-D convolution row-wise */ + for (y = 0; y < sy; y++) { + int pc, c; + pc = gdImageGetPixel (im, 0, y); + for (x = 0; x < sx - 1; x++) { + int c, nc; + c = gdImageGetPixel (im, x, y); + nc = gdImageGetTrueColorPixel (im, x + 1, y); + gdImageSetPixel (im, x, y, + gdImageSubSharpen (pc, c, nc, inner_coeff, + outer_coeff)); + pc = c; + } + c = gdImageGetPixel (im, x, y); + gdImageSetPixel (im, x, y, gdImageSubSharpen + (pc, c, c, inner_coeff, outer_coeff)); + } + } +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdfx.h b/Build/source/libs/gd/libgd-2.1.1/src/gdfx.h new file mode 100644 index 00000000000..cf83d3eb46e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdfx.h @@ -0,0 +1,71 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef GDFX_H +#define GDFX_H 1 + +/* im MUST be square, but can have any size. Returns a new image + of width and height radius * 2, in which the X axis of + the original has been remapped to theta (angle) and the Y axis + of the original has been remapped to rho (distance from center). + This is known as a "polar coordinate transform." */ + +BGD_DECLARE(gdImagePtr) gdImageSquareToCircle(gdImagePtr im, int radius); + +/* Draws the text 'top' and 'bottom' on 'im', curved along the + edge of a circle of radius 'radius', with its + center at 'cx' and 'cy'. 'top' is written clockwise + along the top; 'bottom' is written counterclockwise + along the bottom. 'textRadius' determines the 'height' + of each character; if 'textRadius' is 1/2 of 'radius', + characters extend halfway from the edge to the center. + 'fillPortion' varies from 0 to 1.0, with useful values + from about 0.4 to 0.9, and determines how much of the + 180 degrees of arc assigned to each section of text + is actually occupied by text; 0.9 looks better than + 1.0 which is rather crowded. 'font' is a freetype + font; see gdImageStringFT. 'points' is passed to the + freetype engine and has an effect on hinting; although + the size of the text is determined by radius, textRadius, + and fillPortion, you should pass a point size that + 'hints' appropriately -- if you know the text will be + large, pass a large point size such as 24.0 to get the + best results. 'fgcolor' can be any color, and may have + an alpha component, do blending, etc. + + Returns 0 on success, or an error string. */ + +BGD_DECLARE(char *) gdImageStringFTCircle( + gdImagePtr im, + int cx, + int cy, + double radius, + double textRadius, + double fillPortion, + char *font, + double points, + char *top, + char *bottom, + int fgcolor); + +/* 2.0.16: + * Sharpen function added on 2003-11-19 + * by Paul Troughton (paul<dot>troughton<at>ieee<dot>org) + * Simple 3x3 convolution kernel + * Makes use of seperability + * Faster, but less flexible, than full-blown unsharp masking + * pct is sharpening percentage, and can be greater than 100 + * Silently does nothing to non-truecolor images + * Silently does nothing for pct<0, as not a useful blurring function + * Leaves transparency/alpha-channel untouched + */ + +BGD_DECLARE(void) gdImageSharpen (gdImagePtr im, int pct); + +#endif /* GDFX_H */ + + +#ifdef __cplusplus +} +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdhelpers.c b/Build/source/libs/gd/libgd-2.1.1/src/gdhelpers.c new file mode 100644 index 00000000000..3c063d95523 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdhelpers.c @@ -0,0 +1,98 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gd.h" +#include "gdhelpers.h" +#include <stdlib.h> +#include <string.h> + +#include <sys/types.h> +#include <ctype.h> + +/* TBB: gd_strtok_r is not portable; provide an implementation */ + +#define SEP_TEST (separators[*((unsigned char *) s)]) + +char * +gd_strtok_r (char *s, char *sep, char **state) +{ + char separators[256]; + char *result = 0; + memset (separators, 0, sizeof (separators)); + while (*sep) { + separators[*((unsigned char *) sep)] = 1; + sep++; + } + if (!s) { + /* Pick up where we left off */ + s = *state; + } + /* 1. EOS */ + if (!(*s)) { + *state = s; + return 0; + } + /* 2. Leading separators, if any */ + if (SEP_TEST) { + do { + s++; + } while (SEP_TEST); + /* 2a. EOS after separators only */ + if (!(*s)) { + *state = s; + return 0; + } + } + /* 3. A token */ + result = s; + do { + /* 3a. Token at end of string */ + if (!(*s)) { + *state = s; + return result; + } + s++; + } while (!SEP_TEST); + /* 4. Terminate token and skip trailing separators */ + *s = '\0'; + do { + s++; + } while (SEP_TEST); + /* 5. Return token */ + *state = s; + return result; +} + +void * gdCalloc (size_t nmemb, size_t size) +{ + return calloc (nmemb, size); +} + +void * +gdMalloc (size_t size) +{ + return malloc (size); +} + +void * +gdRealloc (void *ptr, size_t size) +{ + return realloc (ptr, size); +} + +void * +gdReallocEx (void *ptr, size_t size) +{ + void *newPtr = gdRealloc (ptr, size); + if (!newPtr && ptr) + gdFree(ptr); + return newPtr; +} + +BGD_DECLARE(void) gdFree (void *ptr) +{ + free (ptr); +} + + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdhelpers.h b/Build/source/libs/gd/libgd-2.1.1/src/gdhelpers.h new file mode 100644 index 00000000000..2a96b8b4e55 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdhelpers.h @@ -0,0 +1,76 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef GDHELPERS_H +#define GDHELPERS_H 1 + + /* sys/types.h is needed for size_t on Sparc-SunOS-4.1 */ +#ifndef _WIN32_WCE +#include <sys/types.h> +#else +#include <stdlib.h> +#endif /* _WIN32_WCE */ + + /* TBB: strtok_r is not universal; provide an implementation of it. */ + + char * gd_strtok_r (char *s, char *sep, char **state); + + /* These functions wrap memory management. gdFree is + in gd.h, where callers can utilize it to correctly + free memory allocated by these functions with the + right version of free(). */ + void *gdCalloc (size_t nmemb, size_t size); + void *gdMalloc (size_t size); + void *gdRealloc (void *ptr, size_t size); + /* The extended version of gdReallocEx will free *ptr if the + * realloc fails */ + void *gdReallocEx (void *ptr, size_t size); + + /* Returns nonzero if multiplying the two quantities will + result in integer overflow. Also returns nonzero if + either quantity is negative. By Phil Knirsch based on + netpbm fixes by Alan Cox. */ + + int overflow2(int a, int b); + + /* 2.0.16: portable mutex support for thread safety. */ +#if defined(CPP_SHARP) +# define gdMutexDeclare(x) +# define gdMutexSetup(x) +# define gdMutexShutdown(x) +# define gdMutexLock(x) +# define gdMutexUnlock(x) +#elif defined(_WIN32) + /* 2.0.18: must include windows.h to get CRITICAL_SECTION. */ +# include <windows.h> +# define gdMutexDeclare(x) CRITICAL_SECTION x +# define gdMutexSetup(x) InitializeCriticalSection(&x) +# define gdMutexShutdown(x) DeleteCriticalSection(&x) +# define gdMutexLock(x) EnterCriticalSection(&x) +# define gdMutexUnlock(x) LeaveCriticalSection(&x) +#elif defined(HAVE_PTHREAD) +# include <pthread.h> +# define gdMutexDeclare(x) pthread_mutex_t x +# define gdMutexSetup(x) pthread_mutex_init(&x, 0) +# define gdMutexShutdown(x) pthread_mutex_destroy(&x) +# define gdMutexLock(x) pthread_mutex_lock(&x) +# define gdMutexUnlock(x) pthread_mutex_unlock(&x) +#else +# define gdMutexDeclare(x) +# define gdMutexSetup(x) +# define gdMutexShutdown(x) +# define gdMutexLock(x) +# define gdMutexUnlock(x) +#endif /* _WIN32 || HAVE_PTHREAD */ + +#define DPCM2DPI(dpcm) (unsigned int)((dpcm)*2.54 + 0.5) +#define DPM2DPI(dpm) (unsigned int)((dpm)*0.0254 + 0.5) +#define DPI2DPCM(dpi) (unsigned int)((dpi)/2.54 + 0.5) +#define DPI2DPM(dpi) (unsigned int)((dpi)/0.0254 + 0.5) + +#endif /* GDHELPERS_H */ + +#ifdef __cplusplus +} +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdkanji.c b/Build/source/libs/gd/libgd-2.1.1/src/gdkanji.c new file mode 100644 index 00000000000..ab8c0df82df --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdkanji.c @@ -0,0 +1,587 @@ +/* gdkanji.c (Kanji code converter) */ +/* written by Masahito Yamaga (ma@yama-ga.com) */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "gd.h" +#include "gdhelpers.h" +#include "gd_errors.h" + +#ifdef HAVE_ERRNO_H +#include <errno.h> +#endif + +#include <stdarg.h> +#if defined(HAVE_ICONV_H) +#include <iconv.h> +#endif + +#ifndef HAVE_ICONV_T_DEF +typedef void *iconv_t; +#endif + +#ifndef HAVE_ICONV +#define ICONV_CONST /**/ +iconv_t iconv_open (const char *, const char *); +size_t iconv (iconv_t, ICONV_CONST char **, size_t *, char **, size_t *); +int iconv_close (iconv_t); + +iconv_t +iconv_open (const char *tocode, const char *fromcode) +{ + (void)tocode; + (void)fromcode; + return (iconv_t) (-1); +} + +size_t +iconv (iconv_t cd, ICONV_CONST char **inbuf, size_t * inbytesleft, + char **outbuf, size_t * outbytesleft) +{ + (void)cd; + (void)inbuf; + (void)inbytesleft; + (void)outbuf; + (void)outbytesleft; + return 0; +} + +int +iconv_close (iconv_t cd) +{ + (void)cd; + return 0; +} + +#endif /* !HAVE_ICONV */ + +#define LIBNAME "any2eucjp()" + +#if defined(__MSC__) || defined(__BORLANDC__) || defined(__TURBOC__) || defined(_Windows) || defined(MSDOS) +#ifndef SJISPRE +#define SJISPRE 1 +#endif +#endif + +#ifdef TRUE +#undef TRUE +#endif +#ifdef FALSE +#undef FALSE +#endif + +#define TRUE 1 +#define FALSE 0 + +#define NEW 1 +#define OLD 2 +#define ESCI 3 +#define NEC 4 +#define EUC 5 +#define SJIS 6 +#define EUCORSJIS 7 +#define ASCII 8 + +#define NEWJISSTR "JIS7" +#define OLDJISSTR "jis" +#define EUCSTR "eucJP" +#define SJISSTR "SJIS" + +#define ESC 27 +#define SS2 142 + +/* DetectKanjiCode() derived from DetectCodeType() by Ken Lunde. */ + +static int +DetectKanjiCode (unsigned char *str) +{ + static int whatcode = ASCII; + int oldcode = ASCII; + int c, i; + char *lang = NULL; + + c = '\1'; + i = 0; + + if (whatcode != EUCORSJIS && whatcode != ASCII) { + oldcode = whatcode; + whatcode = ASCII; + } + + while ((whatcode == EUCORSJIS || whatcode == ASCII) && c != '\0') { + if ((c = str[i++]) != '\0') { + if (c == ESC) { + c = str[i++]; + if (c == '$') { + c = str[i++]; + if (c == 'B') + whatcode = NEW; + else if (c == '@') + whatcode = OLD; + } else if (c == '(') { + c = str[i++]; + if (c == 'I') + whatcode = ESCI; + } else if (c == 'K') + whatcode = NEC; + } else if ((c >= 129 && c <= 141) || (c >= 143 && c <= 159)) + whatcode = SJIS; + else if (c == SS2) { + c = str[i++]; + if ((c >= 64 && c <= 126) || (c >= 128 && c <= 160) + || (c >= 224 && c <= 252)) + whatcode = SJIS; + else if (c >= 161 && c <= 223) + whatcode = EUCORSJIS; + } else if (c >= 161 && c <= 223) { + c = str[i++]; + if (c >= 240 && c <= 254) + whatcode = EUC; + else if (c >= 161 && c <= 223) + whatcode = EUCORSJIS; + else if (c >= 224 && c <= 239) { + whatcode = EUCORSJIS; + while (c >= 64 && c != '\0' && whatcode == EUCORSJIS) { + if (c >= 129) { + if (c <= 141 || (c >= 143 && c <= 159)) + whatcode = SJIS; + else if (c >= 253 && c <= 254) + whatcode = EUC; + } + c = str[i++]; + } + } else if (c <= 159) + whatcode = SJIS; + } else if (c >= 240 && c <= 254) + whatcode = EUC; + else if (c >= 224 && c <= 239) { + c = str[i++]; + if ((c >= 64 && c <= 126) || (c >= 128 && c <= 160)) + whatcode = SJIS; + else if (c >= 253 && c <= 254) + whatcode = EUC; + else if (c >= 161 && c <= 252) + whatcode = EUCORSJIS; + } + } + } + +#ifdef DEBUG + if (whatcode == ASCII) + gd_error_ex(GD_DEBUG, "Kanji code not included."); + else if (whatcode == EUCORSJIS) + gd_error_ex(GD_DEBUG, "Kanji code not detected."); + else + gd_error_ex(GD_DEBUG, "Kanji code detected at %d byte.", i); +#endif + + if (whatcode == EUCORSJIS && oldcode != ASCII) + whatcode = oldcode; + + if (whatcode == EUCORSJIS) { + if (getenv ("LC_ALL")) + lang = getenv ("LC_ALL"); + else if (getenv ("LC_CTYPE")) + lang = getenv ("LC_CTYPE"); + else if (getenv ("LANG")) + lang = getenv ("LANG"); + + if (lang) { + if (strcmp (lang, "ja_JP.SJIS") == 0 || +#ifdef hpux + strcmp (lang, "japanese") == 0 || +#endif + strcmp (lang, "ja_JP.mscode") == 0 || + strcmp (lang, "ja_JP.PCK") == 0) + whatcode = SJIS; + else if (strncmp (lang, "ja", 2) == 0) +#ifdef SJISPRE + whatcode = SJIS; +#else + whatcode = EUC; +#endif + } + } + + if (whatcode == EUCORSJIS) +#ifdef SJISPRE + whatcode = SJIS; +#else + whatcode = EUC; +#endif + + return whatcode; +} + +/* SJIStoJIS() is sjis2jis() by Ken Lunde. */ + +static void +SJIStoJIS (int *p1, int *p2) +{ + register unsigned char c1 = *p1; + register unsigned char c2 = *p2; + register int adjust = c2 < 159; + register int rowOffset = c1 < 160 ? 112 : 176; + register int cellOffset = adjust ? (31 + (c2 > 127)) : 126; + + *p1 = ((c1 - rowOffset) << 1) - adjust; + *p2 -= cellOffset; +} + +/* han2zen() was derived from han2zen() written by Ken Lunde. */ + +#define IS_DAKU(c) ((c >= 182 && c <= 196) || (c >= 202 && c <= 206) || (c == 179)) +#define IS_HANDAKU(c) (c >= 202 && c <= 206) + +static void +han2zen (int *p1, int *p2) +{ + int c = *p1; + int daku = FALSE; + int handaku = FALSE; + int mtable[][2] = { + {129, 66}, + {129, 117}, + {129, 118}, + {129, 65}, + {129, 69}, + {131, 146}, + {131, 64}, + {131, 66}, + {131, 68}, + {131, 70}, + {131, 72}, + {131, 131}, + {131, 133}, + {131, 135}, + {131, 98}, + {129, 91}, + {131, 65}, + {131, 67}, + {131, 69}, + {131, 71}, + {131, 73}, + {131, 74}, + {131, 76}, + {131, 78}, + {131, 80}, + {131, 82}, + {131, 84}, + {131, 86}, + {131, 88}, + {131, 90}, + {131, 92}, + {131, 94}, + {131, 96}, + {131, 99}, + {131, 101}, + {131, 103}, + {131, 105}, + {131, 106}, + {131, 107}, + {131, 108}, + {131, 109}, + {131, 110}, + {131, 113}, + {131, 116}, + {131, 119}, + {131, 122}, + {131, 125}, + {131, 126}, + {131, 128}, + {131, 129}, + {131, 130}, + {131, 132}, + {131, 134}, + {131, 136}, + {131, 137}, + {131, 138}, + {131, 139}, + {131, 140}, + {131, 141}, + {131, 143}, + {131, 147}, + {129, 74}, + {129, 75} + }; + + if (*p2 == 222 && IS_DAKU (*p1)) + daku = TRUE; /* Daku-ten */ + else if (*p2 == 223 && IS_HANDAKU (*p1)) + handaku = TRUE; /* Han-daku-ten */ + + *p1 = mtable[c - 161][0]; + *p2 = mtable[c - 161][1]; + + if (daku) { + if ((*p2 >= 74 && *p2 <= 103) || (*p2 >= 110 && *p2 <= 122)) + (*p2)++; + else if (*p2 == 131 && *p2 == 69) + *p2 = 148; + } else if (handaku && *p2 >= 110 && *p2 <= 122) + (*p2) += 2; +} + +/* Recast strcpy to handle unsigned chars used below. */ +#define ustrcpy(A,B) (strcpy((char*)(A),(const char*)(B))) + +static void +do_convert (unsigned char **to_p, unsigned char **from_p, const char *code) +{ + unsigned char *to = *to_p; + unsigned char *from = *from_p; +#ifdef HAVE_ICONV + iconv_t cd; + size_t from_len, to_len; + + if ((cd = iconv_open (EUCSTR, code)) == (iconv_t) - 1) { + gd_error ("iconv_open() error"); +#ifdef HAVE_ERRNO_H + if (errno == EINVAL) + gd_error ("invalid code specification: \"%s\" or \"%s\"", EUCSTR, code); +#endif + ustrcpy (to, from); + return; + } + + from_len = strlen ((const char *)from) + 1; + to_len = BUFSIZ; + + if ((int) (iconv (cd, (char **)from_p, &from_len, (char **)to_p, &to_len)) + == -1) { +#ifdef HAVE_ERRNO_H + if (errno == EINVAL) + gd_error ("invalid end of input string"); + else if (errno == EILSEQ) + gd_error ("invalid code in input string"); + else if (errno == E2BIG) + gd_error ("output buffer overflow at do_convert()"); + else +#endif + gd_error ("something happen"); + ustrcpy (to, from); + return; + } + + if (iconv_close (cd) != 0) { + gd_error ("iconv_close() error"); + } +#else + int p1, p2, i, j; + int jisx0208 = FALSE; + int hankaku = FALSE; + + j = 0; + if (strcmp (code, NEWJISSTR) == 0 || strcmp (code, OLDJISSTR) == 0) { + for (i = 0; from[i] != '\0' && j < BUFSIZ; i++) { + if (from[i] == ESC) { + i++; + if (from[i] == '$') { + jisx0208 = TRUE; + hankaku = FALSE; + i++; + } else if (from[i] == '(') { + jisx0208 = FALSE; + i++; + if (from[i] == 'I') /* Hankaku Kana */ + hankaku = TRUE; + else + hankaku = FALSE; + } + } else { + if (jisx0208) + to[j++] = from[i] + 128; + else if (hankaku) { + to[j++] = SS2; + to[j++] = from[i] + 128; + } else + to[j++] = from[i]; + } + } + } else if (strcmp (code, SJISSTR) == 0) { + for (i = 0; from[i] != '\0' && j < BUFSIZ; i++) { + p1 = from[i]; + if (p1 < 127) + to[j++] = p1; + else if ((p1 >= 161) && (p1 <= 223)) { + /* Hankaku Kana */ + to[j++] = SS2; + to[j++] = p1; + } else { + p2 = from[++i]; + SJIStoJIS (&p1, &p2); + to[j++] = p1 + 128; + to[j++] = p2 + 128; + } + } + } else { + gd_error ("invalid code specification: \"%s\"", code); + return; + } + + if (j >= BUFSIZ) { + gd_error ("output buffer overflow at do_convert()"); + ustrcpy (to, from); + } else + to[j] = '\0'; +#endif /* HAVE_ICONV */ +} + +static int +do_check_and_conv (unsigned char *to, unsigned char *from) +{ + static unsigned char tmp[BUFSIZ]; + unsigned char *tmp_p = &tmp[0]; + int p1, p2, i, j; + int kanji = TRUE; + + switch (DetectKanjiCode (from)) { + case NEW: + gd_error_ex(GD_DEBUG, "Kanji code is New JIS."); + do_convert (&tmp_p, &from, NEWJISSTR); + break; + case OLD: + gd_error_ex(GD_DEBUG, "Kanji code is Old JIS."); + do_convert (&tmp_p, &from, OLDJISSTR); + break; + case ESCI: + gd_error_ex(GD_DEBUG, "This string includes Hankaku-Kana (jisx0201) escape sequence [ESC] + ( + I."); + do_convert (&tmp_p, &from, NEWJISSTR); + break; + case NEC: + gd_error_ex(GD_DEBUG, "Kanji code is NEC Kanji."); + gd_error("cannot convert NEC Kanji."); + ustrcpy (tmp, from); + kanji = FALSE; + break; + case EUC: + gd_error_ex(GD_DEBUG, "Kanji code is EUC."); + ustrcpy (tmp, from); + break; + case SJIS: + gd_error_ex(GD_DEBUG, "Kanji code is SJIS."); + do_convert (&tmp_p, &from, SJISSTR); + break; + case EUCORSJIS: + gd_error_ex(GD_DEBUG, "Kanji code is EUC or SJIS."); + ustrcpy (tmp, from); + kanji = FALSE; + break; + case ASCII: + gd_error_ex(GD_DEBUG, "This is ASCII string."); + ustrcpy (tmp, from); + kanji = FALSE; + break; + default: + gd_error_ex(GD_DEBUG, "This string includes unknown code."); + ustrcpy (tmp, from); + kanji = FALSE; + break; + } + + /* Hankaku Kana ---> Zenkaku Kana */ + if (kanji) { + j = 0; + for (i = 0; tmp[i] != '\0' && j < BUFSIZ; i++) { + if (tmp[i] == SS2) { + p1 = tmp[++i]; + if (tmp[i + 1] == SS2) { + p2 = tmp[i + 2]; + if (p2 == 222 || p2 == 223) + i += 2; + else + p2 = 0; + } else + p2 = 0; + han2zen (&p1, &p2); + SJIStoJIS (&p1, &p2); + to[j++] = p1 + 128; + to[j++] = p2 + 128; + } else + to[j++] = tmp[i]; + } + + if (j >= BUFSIZ) { + gd_error("output buffer overflow at Hankaku --> Zenkaku"); + ustrcpy (to, tmp); + } else + to[j] = '\0'; + } else + ustrcpy (to, tmp); + + return kanji; +} + +int +any2eucjp (unsigned char *dest, unsigned char *src, unsigned int dest_max) +{ + static unsigned char tmp_dest[BUFSIZ]; + int ret; + + if (strlen ((const char *) src) >= BUFSIZ) { + gd_error("input string too large"); + return -1; + } + if (dest_max > BUFSIZ) { + gd_error + ("invalid maximum size of destination\nit should be less than %d.", + BUFSIZ); + return -1; + } + ret = do_check_and_conv (tmp_dest, src); + if (strlen ((const char *) tmp_dest) >= dest_max) { + gd_error("output buffer overflow"); + ustrcpy (dest, src); + return -1; + } + ustrcpy (dest, tmp_dest); + return ret; +} + +#if 0 +unsigned int +strwidth (unsigned char *s) +{ + unsigned char *t; + unsigned int i; + + t = (unsigned char *) gdMalloc (BUFSIZ); + any2eucjp (t, s, BUFSIZ); + i = strlen (t); + gdFree (t); + return i; +} + +#ifdef DEBUG +int +main () +{ + unsigned char input[BUFSIZ]; + unsigned char *output; + unsigned char *str; + int c, i = 0; + + while ((c = fgetc (stdin)) != '\n' && i < BUFSIZ) + input[i++] = c; + input[i] = '\0'; + + printf ("input : %d bytes\n", strlen ((const char *) input)); + printf ("output: %d bytes\n", strwidth (input)); + + output = (unsigned char *) gdMalloc (BUFSIZ); + any2eucjp (output, input, BUFSIZ); + str = output; + while (*str != '\0') + putchar (*(str++)); + putchar ('\n'); + gdFree (output); + + return 0; +} +#endif +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdparttopng.c b/Build/source/libs/gd/libgd-2.1.1/src/gdparttopng.c new file mode 100644 index 00000000000..42d6df20368 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdparttopng.c @@ -0,0 +1,61 @@ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> /* For atoi */ +#include "gd.h" + +/* A short program which converts a .png file into a .gd file, for + your convenience in creating images on the fly from a + basis image that must be loaded quickly. The .gd format + is not intended to be a general-purpose format. */ + +int +main (int argc, char **argv) +{ + gdImagePtr im; + FILE *in, *out; + int x, y, w, h; + + if (argc != 7) { + fprintf (stderr, + "Usage: gdparttopng filename.gd filename.png x y w h\n"); + exit (1); + } + in = fopen (argv[1], "rb"); + if (!in) { + fprintf(stderr, "Input file does not exist!\n"); + exit (1); + } + + x = atoi (argv[3]); + y = atoi (argv[4]); + w = atoi (argv[5]); + h = atoi (argv[6]); + + printf ("Extracting from (%d, %d), size is %dx%d\n", x, y, w, h); + + im = gdImageCreateFromGd2Part (in, x, y, w, h); + fclose (in); + if (!im) { + fprintf(stderr, "Input is not in GD2 format!\n"); + exit (1); + } + out = fopen (argv[2], "wb"); + if (!out) { + fprintf(stderr, "Output file cannot be written to!\n"); + gdImageDestroy (im); + exit (1); + } +#ifdef HAVE_LIBPNG + gdImagePng (im, out); +#else + fprintf(stderr, "No PNG library support.\n"); +#endif + fclose (out); + gdImageDestroy (im); + + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdpp.cxx b/Build/source/libs/gd/libgd-2.1.1/src/gdpp.cxx new file mode 100644 index 00000000000..a8101fca29f --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdpp.cxx @@ -0,0 +1,272 @@ +/* ***************************************************************************** +** $Id$ +** Initial file written and documented by: +** Kevin Shepherd <kshepherd@php.net> December 2007 +** of Scarlet Line http://www.scarletline.com/ +*******************************************************************************/ +/** \file gdpp.cxx + \brief Implements the non-trivial methods of GD::Image. + + Implementation of the more complex methods defined + in gdpp.h. + Notably includes the methods which determine the image file + format of a file before reading it into memory. +*/ +#ifdef __cplusplus +#include "gdpp.h" + +namespace GD + { + /** + Load an image from a file, after attempting to + determine it's image file format. + Invoke CreateFrom with an already opened + pointer to a file containing the desired image. + CreateFrom does not close the file. + \param[in] in An opened FILE * pointer. + \return true for success, or false if unable to load the image (most often because the + file is corrupt or does not contain a recognized image format). + You can call Width() and Height() member functions of the image to determine its size. + */ + bool Image::CreateFrom(FILE * in) + { + bool rtn; + int c = fgetc(in); + ungetc(c, in); + switch (c) + { + /* PNG + The first eight bytes of a PNG file always contain the following (decimal) values: + 0x89 0x50 0x4E 0x47 0x0D 0x0A 0x1A 0x0A + == .PNG\r\n.\n + */ +#ifdef HAVE_LIBPNG + case 0x89: // PNG + rtn = CreateFromPng(in); + break; +#endif + /* GIF + 0x47 0x49 0x46 + */ + case 0x47: // GIF + rtn = CreateFromGif(in); + break; +#ifdef HAVE_LIBJPEG + /* JPEG + A JFIF-standard file will start with the four bytes (hex) FF D8 FF E0, + followed by two variable bytes (often hex 00 10), followed by 'JFIF'. + */ + case 0xFF: // JPEG + rtn = CreateFromJpeg(in); + break; +#endif + /* WBMP + WBMP Type 0: B/W, Uncompressed bitmap is the only gd supported type + */ + case 0x00: // WBMP + rtn = CreateFromWBMP(in); + break; + /* GD2 + 0x67 0x64 0x32 0x00 + == GD2\0 + Starts with gd2 + */ + case 0x67: // GD2 + rtn = CreateFromGd2(in); + break; + /* GD + 0xFF 0xFE + or + 0xFF 0xFF + Conflicts with Jpeg + */ + /* XBM + #define test_width 16 + #define test_height 7 + */ + case 0x23: // XBM + rtn = CreateFromXbm(in); + break; + default: + rtn = false; + break; + } + return rtn; + } + + /** + Load an image from a standard input stream, after attempting to + determine it's image file format. + Invoke CreateFrom with an already opened stream + containing the desired image. + CreateFrom does not close the stream. + \param[in] in An opened standard library input stream. + \return true for success, or false if unable to load the image (most often because the + file is corrupt or does not contain a recognized image format). + You can call Width() and Height() member functions of the image to determine its size. + Example usage, convert anything to gif: + #include <fstream> + #include <gdpp.h> + + std::ifstream in("image.xxx", std::ios_base::in | std::ios_base::binary ); + GD::Image im; + im.CreateFrom(in); + if (im.good()) + { + std::ofstream out("image.gif", std::ios_base::out | std::ios_base::binary ); + im.Gif(out); + } + */ + bool Image::CreateFrom(std::istream & in) + { + bool rtn; + switch (in.peek()) + { +#ifdef HAVE_LIBPNG + /* PNG + The first eight bytes of a PNG file always contain the following (decimal) values: + 0x89 0x50 0x4E 0x47 0x0D 0x0A 0x1A 0x0A + == .PNG\r\n.\n + */ + case 0x89: // PNG + rtn = CreateFromPng(in); + break; +#endif + + /* GIF + 0x47 0x49 0x46 + */ + case 0x47: // GIF + rtn = CreateFromGif(in); + break; + +#ifdef HAVE_LIBJPEG + /* JPEG + A JFIF-standard file will start with the four bytes (hex) FF D8 FF E0, + followed by two variable bytes (often hex 00 10), followed by 'JFIF'. + */ + case 0xFF: // JPEG + rtn = CreateFromJpeg(in); + break; +#endif + + /* WBMP + WBMP Type 0: B/W, Uncompressed bitmap is the only gd supported type + */ + case 0x00: // WBMP + rtn = CreateFromWBMP(in); + break; + /* GD2 + 0x67 0x64 0x32 0x00 + == GD2\0 + Starts with gd2 + */ + case 0x67: // GD2 + rtn = CreateFromGd2(in); + break; + /* GD + 0xFF 0xFE + or + 0xFF 0xFF + Conflicts with Jpeg + */ + default: + rtn = false; + break; + } + return rtn; + } + + /** + Load an image from an in-RAM memory block, after attempting to + determine it's image format. + CreateFrom does not de-allocate the memory. + \param[in] size The byte count of the memory block. + \param[in] data A pointer to the memory block. + \return true for success, or false if unable to load the image (most often because the + formatting is corrupt or does not contain a recognized image format). + You can call Width() and Height() member functions of the image to determine its size. + */ + bool Image::CreateFrom(int size, void * data) + { + bool rtn; + switch (((unsigned char * )data)[0]) + { + +#ifdef HAVE_LIBPNG + /* PNG + The first eight bytes of a PNG file always contain the following (decimal) values: + 0x89 0x50 0x4E 0x47 0x0D 0x0A 0x1A 0x0A + == .PNG\r\n.\n + */ + case 0x89: // PNG + rtn = CreateFromPng(size, data); + break; +#endif + /* GIF + 0x47 0x49 0x46 + */ + case 0x47: // GIF + rtn = CreateFromGif(size, data); + break; + +#ifdef HAVE_LIBJPEG + /* JPEG + A JFIF-standard file will start with the four bytes (hex) FF D8 FF E0, + followed by two variable bytes (often hex 00 10), followed by 'JFIF'. + */ + case 0xFF: // JPEG + rtn = CreateFromJpeg(size, data); + break; +#endif + + /* WBMP + WBMP Type 0: B/W, Uncompressed bitmap is the only gd supported type + */ + case 0x00: // WBMP + rtn = CreateFromWBMP(size, data); + break; + /* GD2 + 0x67 0x64 0x32 0x00 + == GD2\0 + Starts with gd2 + */ + case 0x67: // GD2 + rtn = CreateFromGd2(size, data); + break; + /* GD + 0xFF 0xFE + or + 0xFF 0xFF + Conflicts with Jpeg + */ + default: + rtn = false; + break; + } + return rtn; + } + } // namespace GD +/** + Load an image from a standard input stream, regardless of it's image file format. + You can call Width() and Height() member functions of the image to determine its size. + Example usage, convert anything to gif: + #include <fstream> + #include <gdpp.h> + + std::ifstream in("image.xxx", std::ios_base::in | std::ios_base::binary ); + GD::Image im; + in >> im; + if (im.good()) + { + std::ofstream out("image.gif", std::ios_base::out | std::ios_base::binary ); + im.Gif(out); + } +*/ +std::istream & operator>> (std::istream & in, GD::Image & img) + { + img.CreateFrom(in); + return in; + } + +#endif /* __cplusplus */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdpp.h b/Build/source/libs/gd/libgd-2.1.1/src/gdpp.h new file mode 100644 index 00000000000..2ebda162e1c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdpp.h @@ -0,0 +1,1546 @@ +/* ***************************************************************************** +** $Id$ +** Initial file written and documented by: +** Kevin Shepherd <kshepherd@php.net> December 2007 +** of Scarlet Line http://www.scarletline.com/ +** with contributions from Torben Nielsen. +*******************************************************************************/ +/** \file gdpp.h + \brief Object Oriented C++ wrappers around libgd functionality. + + Example usage, convert png to gif: + #include <fstream> + #include <gdpp.h> + + std::ifstream in("image.png", std::ios_base::in | std::ios_base::binary ); + GD::Image im(in, GD::Png_tag()); + if (im.good()) + { + std::ofstream out("image.gif", std::ios_base::out | std::ios_base::binary ); + im.Gif(out); + } +*/ +#ifdef __cplusplus +#ifndef _gdpp_h +#define _gdpp_h + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gd_io_stream.h" +#include <string> + +/// namespace GD:: contains the C++ wrapper classes for libgd +/** This namespace is primarily to avoid name clashes, and to + contain all of the gd classes within one namespace. + It is not recommended to use the "using namespace" directive with this namespace. + Example usage: + GD::Image im(64, 32, true); // Create a truecolor image 64 pixels wide by 32 pixels high + GD::Point pt(10, 8); // The point at x=10, y=8. + GD::Size sz(16, 8); // The size width=16, height=8. + GD::TrueColor col(0xFF, 0, 0); // The colour red; R=255, G=0, B=0. + im.Rectangle(pt, sz, col.Int()); // Draw a red rectangle with top left corner at pt, of size sz. +*/ +namespace GD +{ +/** This class GD::Point stores a point in two dimensions, somewhere + on the plane of an image. +*/ +class BGD_EXPORT_DATA_PROT Point +{ +public: + // Constructors + Point(int x, int y) + :_x(x), _y(y) {} + Point(const Point & p) + :_x(p._x), _y(p._y) {} + Point() + :_x(0), _y(0) {} + Point & operator=(const Point & p) { + _x = p._x; + _y = p._y; + return (* this); + } + // Accessors + int X() const { + return _x; + } + int Y() const { + return _y; + } + // Updaters + void X(int x) { + _x = x; + } + void Y(int y) { + _y = y; + } + void set(int x, int y) { + _x = x; + _y = y; + } + int & lhsX() { + return _x; + } + int & lhsY() { + return _y; + } + + gdPointPtr as_gdPointPtr() { + return (gdPointPtr) this; + } +protected: + int _x, _y; +}; +typedef Point * PointPtr; +/** This class GD::Size stores length in two dimensions. + Giving the size of an area as width and height. +*/ +class BGD_EXPORT_DATA_PROT Size +{ +public: + // Constructors + Size(int w, int h) + :_w(w), _h(h) {} + Size(const Size & p) + :_w(p._w), _h(p._h) {} + Size() + :_w(0), _h(0) {} + Size & operator=(const Size & p) { + _w = p._w; + _h = p._h; + return (* this); + } + // Accessors + int W() const { + return _w; + } + int H() const { + return _h; + } + // Updaters + void W(int w) { + _w = w; + } + void H(int h) { + _h = h; + } + void set(int w, int h) { + _w = w; + _h = h; + } + int & lhsW() { + return _w; + } + int & lhsH() { + return _h; + } +protected: + int _w, _h; +}; +typedef Size * SizePtr; + +/** This class GD::TrueColor stores a colour as an RGBA quadruplet. + It can also be read as an integer, and in other colour formats. +*/ +class BGD_EXPORT_DATA_PROT TrueColor +{ +public: + union as_types { + int as_int; + struct uchars { + unsigned char blue, green, red, alpha; + } as_uchar; + }; + TrueColor() { + internal.as_int = 0; + } + TrueColor(int c) { + internal.as_int = c; + } + TrueColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 0) { + internal.as_uchar.alpha = a; + internal.as_uchar.red = r; + internal.as_uchar.green = g; + internal.as_uchar.blue = b; + } + // Accessors + int Int() const { + return internal.as_int; + } + unsigned char Red() const { + return internal.as_uchar.red; + } + unsigned char Green() const { + return internal.as_uchar.green; + } + unsigned char Blue() const { + return internal.as_uchar.blue; + } + unsigned char Alpha() const { + return internal.as_uchar.alpha; + } + // Updaters + void set(int c) { + internal.as_int = c; + } + void set(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 0) { + internal.as_uchar.alpha = a; + internal.as_uchar.red = r; + internal.as_uchar.green = g; + internal.as_uchar.blue = b; + } + void Red(unsigned char c) { + internal.as_uchar.red = c; + } + void Green(unsigned char c) { + internal.as_uchar.green = c; + } + void Blue(unsigned char c) { + internal.as_uchar.blue = c; + } + void Alpha(unsigned char c) { + internal.as_uchar.alpha = c; + } +protected: + as_types internal; +}; +/* The following tags are simply empty structures which are used + to tell the compiler which constructor we want when we know + the image file format. +*/ +struct BGD_EXPORT_DATA_PROT Png_tag {}; +struct BGD_EXPORT_DATA_PROT Gif_tag {}; +struct BGD_EXPORT_DATA_PROT WBMP_tag {}; +struct BGD_EXPORT_DATA_PROT Jpeg_tag {}; +struct BGD_EXPORT_DATA_PROT Gd_tag {}; +struct BGD_EXPORT_DATA_PROT Gd2_tag {}; +struct BGD_EXPORT_DATA_PROT Xbm_tag {}; + +/** This class GD::Image wraps all of the 'C' libgd functionality + for the convenience of C++ users. An instance of this class + corresponds to a single image. +*/ +class BGD_EXPORT_DATA_PROT Image +{ +public: + /** Construct a null image + */ + Image() + :im(0) + {} + /** Construct a blank image, of the given size and colour format type. + \param[in] sx Width of the image + \param[in] sy Height of the image + \param[in] istruecolor Create a true colour image, defaults to false, i.e. create an indexed palette image. + */ + Image(int sx, int sy, bool istruecolor = false) + :im(0) { + if (istruecolor) + CreateTrueColor(sx, sy); + else + Create(sx, sy); + } + /** Construct a blank image, of the given size and colour format type. + \param[in] s Width and height of the image + \param[in] istruecolor Create a true colour image, defaults to false, i.e. create an indexed palette image. + */ + Image(const Size & s, bool istruecolor = false) + :im(0) { + if (istruecolor) + CreateTrueColor(s); + else + Create(s); + } + /** Construct an instance of the GD::Image class, given the internal gdImage poimter. + Note that gdImageDestroy will be called on the image pointer in the destructor. + \param[in] i Pointer to the internal gdImage + */ + Image(gdImagePtr i) + :im(i) {} + /** Copy constructor. Construct an instance of the GD::Image class, + by making a copy of the GD::Image provided. + \param[in] i Reference to the image to be copied + */ + Image(const GD::Image & i) + :im(0) { + Copy(i); + } + /** Construct an image by reading from \p in. This constructor + will first attempt to determine the file format. + \param[in] in The stream containing the image data + */ + Image(std::istream & in) + :im(0) { + CreateFrom(in); + } + /** Construct an image by reading from \p in. This constructor + will first attempt to determine the file format. + \param[in] in An opened FILE * handle to a file containing the image data + */ + Image(FILE * in) + :im(0) { + CreateFrom(in); + } + /** Construct an image by reading from memory block \p data. This constructor + will first attempt to determine the image formatting. + \param[in] size The byte count of the memory block + \param[in] data Pointer to the memory block + */ + Image(int size, void * data) + :im(0) { + CreateFrom(size, data); + } +#ifdef HAVE_LIBPNG + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Png_tag()); // read a png file from input + \param[in] in The stream containing the image data + */ + Image(std::istream & in, Png_tag) + :im(0) { + CreateFromPng(in); + } + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Png_tag()); // read a png file from input + \param[in] in An opened FILE * handle to a file containing the image data + */ + Image(FILE * in, Png_tag) + :im(0) { + CreateFromPng(in); + } + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Png_tag()); // read a png file from input + \param[in] in The io context from which to read the image data + */ + Image(gdIOCtx * in, Png_tag) + :im(0) { + CreateFromPng(in); + } + /** Construct an image by reading from memory block \p data. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(sz, dat, GD::Png_tag()); // read a png file from dat + \param[in] size The byte count of the memory block + \param[in] data Pointer to the memory block + */ + Image(int size, void * data, Png_tag) + :im(0) { + CreateFromPng(size, data); + } +#endif + + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Gif_tag()); // read a gif file from input + \param[in] in The stream containing the image data + */ + Image(std::istream & in, Gif_tag) + :im(0) { + CreateFromGif(in); + } + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Gif_tag()); // read a gif file from input + \param[in] in An opened FILE * handle to a file containing the image data + */ + Image(FILE * in, Gif_tag) + :im(0) { + CreateFromGif(in); + } + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Gif_tag()); // read a gif file from input + \param[in] in The io context from which to read the image data + */ + Image(gdIOCtx * in, Gif_tag) + :im(0) { + CreateFromGif(in); + } + /** Construct an image by reading from memory block \p data. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(sz, dat, GD::Gif_tag()); // read a gif file from dat + \param[in] size The byte count of the memory block + \param[in] data Pointer to the memory block + */ + Image(int size, void * data, Gif_tag) + :im(0) { + CreateFromGif(size, data); + } + + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::WBMP_tag()); // read a monchrome WBMP file from input + \param[in] in The stream containing the image data + */ + Image(std::istream & in, WBMP_tag) + :im(0) { + CreateFromWBMP(in); + } + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::WBMP_tag()); // read a monchrome WBMP file from input + \param[in] in An opened FILE * handle to a file containing the image data + */ + Image(FILE * in, WBMP_tag) + :im(0) { + CreateFromWBMP(in); + } + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::WBMP_tag()); // read a monchrome WBMP file from input + \param[in] in The io context from which to read the image data + */ + Image(gdIOCtx * in, WBMP_tag) + :im(0) { + CreateFromWBMP(in); + } + /** Construct an image by reading from memory block \p data. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(sz, dat, GD::WBMP_tag()); // read a monchrome WBMP file from dat + \param[in] size The byte count of the memory block + \param[in] data Pointer to the memory block + */ + Image(int size, void * data, WBMP_tag) + :im(0) { + CreateFromWBMP(size, data); + } + +#ifdef HAVE_LIBJPEG + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Jpeg_tag()); // read a jpeg file from input + \param[in] in The stream containing the image data + */ + Image(std::istream & in, Jpeg_tag) + :im(0) { + CreateFromJpeg(in); + } + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Jpeg_tag()); // read a jpeg file from input + \param[in] in An opened FILE * handle to a file containing the image data + */ + Image(FILE * in, Jpeg_tag) + :im(0) { + CreateFromJpeg(in); + } + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Jpeg_tag()); // read a jpeg file from input + \param[in] in The io context from which to read the image data + */ + Image(gdIOCtx * in, Jpeg_tag) + :im(0) { + CreateFromJpeg(in); + } + /** Construct an image by reading from memory block \p data. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(sz, dat, GD::Jpeg_tag()); // read a jpeg file from dat + \param[in] size The byte count of the memory block + \param[in] data Pointer to the memory block + */ + Image(int size, void * data, Jpeg_tag) + :im(0) { + CreateFromJpeg(size, data); + } +#endif + + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Gd_tag()); // read a gd file from input + \param[in] in The stream containing the image data + */ + Image(std::istream & in, Gd_tag) + :im(0) { + CreateFromGd(in); + } + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Gd_tag()); // read a gd file from input + \param[in] in An opened FILE * handle to a file containing the image data + */ + Image(FILE * in, Gd_tag) + :im(0) { + CreateFromGd(in); + } + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Gd_tag()); // read a gd file from input + \param[in] in The io context from which to read the image data + */ + Image(gdIOCtx * in, Gd_tag) + :im(0) { + CreateFromGd(in); + } + /** Construct an image by reading from memory block \p data. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(sz, dat, GD::Gd_tag()); // read a gd file from dat + \param[in] size The byte count of the memory block + \param[in] data Pointer to the memory block + */ + Image(int size, void * data, Gd_tag) + :im(0) { + CreateFromGd(size, data); + } + + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Gd2_tag()); // read a gd2 file from input + \param[in] in The stream containing the image data + */ + Image(std::istream & in, Gd2_tag) + :im(0) { + CreateFromGd2(in); + } + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Png_tag()); // read a png file from input + \param[in] in An opened FILE * handle to a file containing the image data + */ + Image(FILE * in, Gd2_tag) + :im(0) { + CreateFromGd2(in); + } + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Gd2_tag()); // read a gd2 file from input + \param[in] in The io context from which to read the image data + */ + Image(gdIOCtx * in, Gd2_tag) + :im(0) { + CreateFromGd2(in); + } + /** Construct an image by reading from memory block \p data. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(sz, dat, GD::Gd2_tag()); // read a gd2 file from dat + \param[in] size The byte count of the memory block + \param[in] data Pointer to the memory block + */ + Image(int size, void * data, Gd2_tag) + :im(0) { + CreateFromGd2(size, data); + } + + /** Construct an image by reading from \p in. + The tag is an empty struct which simply tells the compiler which image read function to use. + e.g. GD::Image img(input, GD::Xbm_tag()); // read an xbm file from input + \param[in] in An opened FILE * handle to a file containing the image data + */ + Image(FILE * in, Xbm_tag) + :im(0) { + CreateFromXbm(in); + } + + ~Image() { + clear(); + } + + /** Assignment Operator. Make this a copy of the GD::Image provided. + \param[in] src Reference to the image to be copied + */ + GD::Image & operator=(const GD::Image & src) { + Copy(src); + return (* this); + } + /** Make this an exact copy of the GD::Image provided. Any existing iamge data is discarded. + \param[in] src Reference to the image to be copied + */ + void Copy(const GD::Image & src) { + int w = src.Width(), h = src.Height(); + if (src.IsTrueColor()) + CreateTrueColor(w, h); + else { + Create(w, h); + PaletteCopy(src); + } + Copy(src, 0, 0, 0, 0, w, h); + } + /** Check to see if this appears to be a valid image + */ + bool good() const { + return (im != 0); + } + // Creation: + /** + Create a palette-based image, with no more than 256 colors. + \param sx Width of the desired image + \param sy Height of the desired image + \return true if it worked, else false + */ + bool Create(int sx, int sy) { + clear(); + return ((im = gdImageCreate(sx, sy)) != 0); + } + /** + Create a truecolor image. + \param sx Width of the desired image + \param sy Height of the desired image + \return true if it worked, else false + */ + bool CreateTrueColor(int sx, int sy) { + clear(); + return ((im = gdImageCreateTrueColor(sx, sy)) != 0); + } + /** + Create a palette-based image, with no more than 256 colors. + \param s Width and height of the desired image + \return true if it worked, else false + */ + bool Create(const Size & s) { + return Create(s.W(), s.H()); + } + /** + Create a truecolor image. + \param s Width and height of the desired image + \return true if it worked, else false + */ + bool CreateTrueColor(const Size & s) { + return CreateTrueColor(s.W(), s.H()); + } + // Create, determining the image format from the data + /// Read an image from an open FILE * handle, after determining the image format + bool CreateFrom(FILE * in); + /// Read an image from an open standard library input stream, after determining the image format + bool CreateFrom(std::istream & in); + /// Read an image from a memory block, after determining the image format + bool CreateFrom(int size, void * data); + +#ifdef HAVE_LIBPNG + // Png + bool CreateFromPng(FILE * in) { + clear(); + return ((im = gdImageCreateFromPng(in)) != 0); + } + bool CreateFromPng(gdIOCtx * in) { + clear(); + return ((im = gdImageCreateFromPngCtx(in)) != 0); + } + bool CreateFromPng(int size, void * data) { + clear(); + return ((im = gdImageCreateFromPngPtr(size, data)) != 0); + } + bool CreateFromPng(std::istream & in) { + clear(); + istreamIOCtx _in_ctx(in); + return ((im = gdImageCreateFromPngCtx( & _in_ctx)) != 0); + } +#endif + + // Gif + bool CreateFromGif(FILE * in) { + clear(); + return ((im = gdImageCreateFromGif(in)) != 0); + } + bool CreateFromGif(gdIOCtx * in) { + clear(); + return ((im = gdImageCreateFromGifCtx(in)) != 0); + } + bool CreateFromGif(int size, void * data) { + clear(); + return ((im = gdImageCreateFromGifPtr(size, data)) != 0); + } + bool CreateFromGif(std::istream & in) { + clear(); + istreamIOCtx _in_ctx(in); + return ((im = gdImageCreateFromGifCtx( & _in_ctx)) != 0); + } + // WBMP + bool CreateFromWBMP(FILE * in) { + clear(); + return ((im = gdImageCreateFromWBMP(in)) != 0); + } + bool CreateFromWBMP(gdIOCtx * in) { + clear(); + return ((im = gdImageCreateFromWBMPCtx(in)) != 0); + } + bool CreateFromWBMP(int size, void * data) { + clear(); + return ((im = gdImageCreateFromWBMPPtr(size, data)) != 0); + } + bool CreateFromWBMP(std::istream & in) { + clear(); + istreamIOCtx _in_ctx(in); + return ((im = gdImageCreateFromWBMPCtx( & _in_ctx)) != 0); + } + +#ifdef HAVE_LIBJPEG + // Jpeg + /** + Load a truecolor image from a JPEG format file. + Invoke CreateFromJpeg with an already opened + pointer to a file containing the desired image. + CreateFromJpeg does not close the file. + \return true for success, or false if unable to load the image (most often because + the file is corrupt or does not contain a JPEG image). + You can call Width() and Height() member functions of the image to determine its + size. The returned image is always a truecolor image. + */ + bool CreateFromJpeg(FILE * in) { + clear(); + return ((im = gdImageCreateFromJpeg(in)) != 0); + } + /** + Load a truecolor image from a JPEG format file. + Invoke CreateFromJpeg with an already opened + pointer to a file containing the desired image. + CreateFromJpeg does not close the file. + \return true for success, or false if unable to load the image (most often because the file is corrupt or does not contain a JPEG image). + You can call Width() and Height() member functions of the image to determine its + size. The returned image is always a truecolor image. + */ + bool CreateFromJpeg(gdIOCtx * in) { + clear(); + return ((im = gdImageCreateFromJpegCtx(in)) != 0); + } + /** + Load a truecolor image from a JPEG format file. + Invoke CreateFromJpeg with an already opened + pointer to a file containing the desired image. + CreateFromJpeg does not close the file. + \return true for success, or false if unable to load the image (most often because the file is corrupt or does not contain a JPEG image). + You can call Width() and Height() member functions of the image to determine its + size. The returned image is always a truecolor image. + */ + bool CreateFromJpeg(int size, void * data) { + clear(); + return ((im = gdImageCreateFromJpegPtr(size, data)) != 0); + } + /** + Load a truecolor image from a JPEG format file. + Invoke CreateFromJpeg with an image file in memory. + \return true for success, or false if unable to load the image (most often because the format is corrupt or does not contain a JPEG image). + You can call Width() and Height() member functions of the image to determine its + size. The returned image is always a truecolor image. + */ + bool CreateFromJpeg(std::istream & in) { + clear(); + istreamIOCtx _in_ctx(in); + return ((im = gdImageCreateFromJpegCtx( & _in_ctx)) != 0); + } +#endif + + // Gd + bool CreateFromGd(FILE * in) { + clear(); + return ((im = gdImageCreateFromGd(in)) != 0); + } + bool CreateFromGd(gdIOCtx * in) { + clear(); + return ((im = gdImageCreateFromGdCtx(in)) != 0); + } + bool CreateFromGd(int size, void * data) { + clear(); + return ((im = gdImageCreateFromGdPtr(size, data)) != 0); + } + bool CreateFromGd(std::istream & in) { + clear(); + istreamIOCtx _in_ctx(in); + return ((im = gdImageCreateFromGdCtx( & _in_ctx)) != 0); + } + // Gd2 + bool CreateFromGd2(FILE * in) { + clear(); + return ((im = gdImageCreateFromGd2(in)) != 0); + } + bool CreateFromGd2(gdIOCtx * in) { + clear(); + return ((im = gdImageCreateFromGd2Ctx(in)) != 0); + } + bool CreateFromGd2(int size, void * data) { + clear(); + return ((im = gdImageCreateFromGd2Ptr(size, data)) != 0); + } + bool CreateFromGd2(std::istream & in) { + clear(); + istreamIOCtx _in_ctx(in); + return ((im = gdImageCreateFromGd2Ctx( & _in_ctx)) != 0); + } + // Gd2 Part + bool CreateFromGd2Part(FILE * in, int srcx, int srcy, int w, int h) { + clear(); + return ((im = gdImageCreateFromGd2Part(in, srcx, srcy, w, h)) != 0); + } + bool CreateFromGd2Part(gdIOCtx * in, int srcx, int srcy, int w, int h) { + clear(); + return ((im = gdImageCreateFromGd2PartCtx(in, srcx, srcy, w, h)) != 0); + } + bool CreateFromGd2Part(int size, void * data, int srcx, int srcy, int w, int h) { + clear(); + return ((im = gdImageCreateFromGd2PartPtr(size, data, srcx, srcy, w, h)) != 0); + } + bool CreateFromGd2Part(std::istream & in, int srcx, int srcy, int w, int h) { + clear(); + istreamIOCtx _in_ctx(in); + return ((im = gdImageCreateFromGd2PartCtx( & _in_ctx, srcx, srcy, w, h)) != 0); + } + bool CreateFromGd2Part(FILE * in, const Point & src, const Size & s) { + return CreateFromGd2Part(in, src.X(), src.Y(), s.W(), s.H()); + } + bool CreateFromGd2Part(gdIOCtx * in, const Point & src, const Size & s) { + return CreateFromGd2Part(in, src.X(), src.Y(), s.W(), s.H()); + } + bool CreateFromGd2Part(int size, void * data, const Point & src, const Size & s) { + return CreateFromGd2Part(size, data, src.X(), src.Y(), s.W(), s.H()); + } + bool CreateFromGd2Part(std::istream & in, const Point & src, const Size & s) { + return CreateFromGd2Part(in, src.X(), src.Y(), s.W(), s.H()); + } + // Xbm + bool CreateFromXbm(FILE * in) { + clear(); + return ((im = gdImageCreateFromXbm(in)) != 0); + } + // Xpm + bool CreateFromXpm(char * filename) { + clear(); + return ((im = gdImageCreateFromXpm(filename)) != 0); + } + bool CreateFromXpm(std::string & filename) { + return CreateFromXpm((char *)(filename.c_str())); + } + + // Accessors, Updaters & Methods: + void SetPixel(int x, int y, int color) { + gdImageSetPixel(im, x, y, color); + } + void SetPixel(const Point & p, int color) { + SetPixel(p.X(), p.Y(), color); + } + int GetPixel(int x, int y) const { + return gdImageGetPixel(im, x, y); + } + int GetPixel(const Point & p) const { + return GetPixel(p.X(), p.Y()); + } + int GetTrueColorPixel(int x, int y) const { + return gdImageGetTrueColorPixel(im, x, y); + } + int GetTrueColorPixel(const Point & p) const { + return GetTrueColorPixel(p.X(), p.Y()); + } + + void SetPixel(int x, int y, TrueColor c) { + SetPixel(x, y, c.Int()); + } + void SetPixel(const Point & p, TrueColor c) { + SetPixel(p.X(), p.Y(), c.Int()); + } + void GetTrueColorPixel(TrueColor & c, int x, int y) const { + c.set(GetTrueColorPixel(x, y)); + } + void GetTrueColorPixel(TrueColor & c, const Point & p) const { + c.set(GetTrueColorPixel(p.X(), p.Y())); + } + + void AABlend() { + gdImageAABlend(im); + } + + void Line(int x1, int y1, int x2, int y2, int color) { + gdImageLine(im, x1, y1, x2, y2, color); + } + void Line(const Point & p1, const Point & p2, int color) { + Line(p1.X(), p1.Y(), p2.X(), p2.Y(), color); + } + void Rectangle(int x1, int y1, int x2, int y2, int color) { + gdImageRectangle(im, x1, y1, x2, y2, color); + } + void Rectangle(const Point & p1, const Point & p2, int color) { + Rectangle(p1.X(), p1.Y(), p2.X(), p2.Y(), color); + } + void Rectangle(const Point & p, const Size & s, int color) { + Rectangle(p.X(), p.Y(), p.X() + s.W(), p.Y() + s.H(), color); + } + void FilledRectangle(int x1, int y1, int x2, int y2, int color) { + gdImageFilledRectangle(im, x1, y1, x2, y2, color); + } + void FilledRectangle(const Point & p1, const Point & p2, int color) { + FilledRectangle(p1.X(), p1.Y(), p2.X(), p2.Y(), color); + } + void FilledRectangle(const Point & p, const Size & s, int color) { + FilledRectangle(p.X(), p.Y(), p.X() + s.W(), p.Y() + s.H(), color); + } + + void SetClip(int x1, int y1, int x2, int y2) { + gdImageSetClip(im, x1, y1, x2, y2); + } + void SetClip(const Point & p1, const Point & p2) { + SetClip(p1.X(), p1.Y(), p2.X(), p2.Y()); + } + void SetClip(const Point & p, const Size & s) { + SetClip(p.X(), p.Y(), p.X() + s.W(), p.Y() + s.H()); + } + void GetClip(int & x1, int & y1, int & x2, int & y2) const { + gdImageGetClip(im, & x1, & y1, & x2, & y2); + } + void GetClip(Point & p1, Point & p2) const { + GetClip(p1.lhsX(), p1.lhsY(), p2.lhsX(), p2.lhsY()); + } + void GetClip(Point & p, Size & s) const { + Point p2; + GetClip(p.lhsX(), p.lhsY(), p2.lhsX(), p2.lhsY()); + s.set(p2.X() - p.X(), p2.Y() - p.Y()); + } + + bool BoundsSafe(int x, int y) const { + return (gdImageBoundsSafe(im, x, y)?true:false); + } + bool BoundsSafe(const Point & p) const { + return BoundsSafe(p.X(), p.Y()); + } + + void Char(gdFontPtr f, int x, int y, int c, int color) { + gdImageChar(im, f, x, y, c, color); + } + void CharUp(gdFontPtr f, int x, int y, int c, int color) { + gdImageCharUp(im, f, x, y, c, color); + } + + void Char(gdFontPtr f, const Point & p, int c, int color) { + Char(f, p.X(), p.Y(), c, color); + } + void CharUp(gdFontPtr f, const Point & p, int c, int color) { + CharUp(f, p.X(), p.Y(), c, color); + } + + void String(gdFontPtr f, int x, int y, unsigned char * s, int color) { + gdImageString(im, f, x, y, (unsigned char *)s, color); + } + void StringUp(gdFontPtr f, int x, int y, unsigned char * s, int color) { + gdImageStringUp(im, f, x, y, (unsigned char *)s, color); + } + void String(gdFontPtr f, int x, int y, unsigned short * s, int color) { + gdImageString16(im, f, x, y, (unsigned short *)s, color); + } + void StringUp(gdFontPtr f, int x, int y, unsigned short * s, int color) { + gdImageStringUp16(im, f, x, y, (unsigned short *)s, color); + } + void String(gdFontPtr f, int x, int y, char * s, int color) { + gdImageString(im, f, x, y, (unsigned char *)s, color); + } + void StringUp(gdFontPtr f, int x, int y, char * s, int color) { + gdImageStringUp(im, f, x, y, (unsigned char *)s, color); + } + void String(gdFontPtr f, int x, int y, const std::string & s, int color) { + String(f, x, y, (char *)s.c_str(), color); + } + void StringUp(gdFontPtr f, int x, int y, const std::string & s, int color) { + StringUp(f, x, y, (char *)s.c_str(), color); + } + + void String(gdFontPtr f, const Point & p, unsigned char * s, int color) { + String(f, p.X(), p.Y(), (unsigned char *)s, color); + } + void StringUp(gdFontPtr f, const Point & p, unsigned char * s, int color) { + StringUp(f, p.X(), p.Y(), (unsigned char *)s, color); + } + void String(gdFontPtr f, const Point & p, unsigned short * s, int color) { + String(f, p.X(), p.Y(), (unsigned short *)s, color); + } + void StringUp(gdFontPtr f, const Point & p, unsigned short * s, int color) { + StringUp(f, p.X(), p.Y(), (unsigned short *)s, color); + } + void String(gdFontPtr f, const Point & p, char * s, int color) { + String(f, p.X(), p.Y(), (unsigned char *)s, color); + } + void StringUp(gdFontPtr f, const Point & p, char * s, int color) { + StringUp(f, p.X(), p.Y(), (unsigned char *)s, color); + } + void String(gdFontPtr f, const Point & p, const std::string & s, int color) { + String(f, p, (char *)s.c_str(), color); + } + void StringUp(gdFontPtr f, const Point & p, const std::string & s, int color) { + StringUp(f, p, (char *)s.c_str(), color); + } + + char * StringFT(int * brect, int fg, char * fontlist, double ptsize, double angle, + int x, int y, char * string) { + return gdImageStringFT(im, brect, fg, fontlist, ptsize, angle, x, y, string); + } + char * StringFT(int * brect, int fg, char * fontlist, double ptsize, double angle, + int x, int y, char * string, gdFTStringExtraPtr strex) { + return gdImageStringFTEx(im, brect, fg, fontlist, ptsize, angle, x, y, string, strex); + } + char * StringFT(int * brect, int fg, char * fontlist, double ptsize, double angle, + int x, int y, const std::string & string) { + return StringFT(brect, fg, fontlist, ptsize, angle, x, y, (char *)string.c_str()); + } + char * StringFT(int * brect, int fg, char * fontlist, double ptsize, double angle, + int x, int y, const std::string & string, gdFTStringExtraPtr strex) { + return StringFT(brect, fg, fontlist, ptsize, angle, x, y, (char *)string.c_str(), strex); + } + + char * StringFT(int * brect, int fg, char * fontlist, double ptsize, double angle, + const Point & p, char * string) { + return StringFT(brect, fg, fontlist, ptsize, angle, p.X(), p.Y(), string); + } + char * StringFT(int * brect, int fg, char * fontlist, double ptsize, double angle, + const Point & p, char * string, gdFTStringExtraPtr strex) { + return StringFT(brect, fg, fontlist, ptsize, angle, p.X(), p.Y(), string, strex); + } + char * StringFT(int * brect, int fg, char * fontlist, double ptsize, double angle, + const Point & p, const std::string & string) { + return StringFT(brect, fg, fontlist, ptsize, angle, p, (char *)string.c_str()); + } + char * StringFT(int * brect, int fg, char * fontlist, double ptsize, double angle, + const Point & p, const std::string & string, gdFTStringExtraPtr strex) { + return StringFT(brect, fg, fontlist, ptsize, angle, p, (char *)string.c_str(), strex); + } + + void Polygon(gdPointPtr p, int n, int c) { + gdImagePolygon(im, p, n, c); + } + void OpenPolygon(gdPointPtr p, int n, int c) { + gdImageOpenPolygon(im, p, n, c); + } + void FilledPolygon(gdPointPtr p, int n, int c) { + gdImageFilledPolygon(im, p, n, c); + } + + void Polygon(PointPtr p, int n, int c) { + Polygon(p->as_gdPointPtr(), n, c); + } + void OpenPolygon(PointPtr p, int n, int c) { + OpenPolygon(p->as_gdPointPtr(), n, c); + } + void FilledPolygon(PointPtr p, int n, int c) { + FilledPolygon(p->as_gdPointPtr(), n, c); + } + + int ColorAllocate(int r, int g, int b) { + return gdImageColorAllocate(im, r, g, b); + } + int ColorAllocate(int r, int g, int b, int a) { + return gdImageColorAllocateAlpha(im, r, g, b, a); + } + + int ColorClosest(int r, int g, int b) const { + return gdImageColorClosest(im, r, g, b); + } + int ColorClosest(int r, int g, int b, int a) const { + return gdImageColorClosestAlpha(im, r, g, b, a); + } + int ColorClosestHWB(int r, int g, int b) const { + return gdImageColorClosestHWB(im, r, g, b); + } + int ColorExact(int r, int g, int b) const { + return gdImageColorExact(im, r, g, b); + } + int ColorExact(int r, int g, int b, int a) const { + return gdImageColorExactAlpha(im, r, g, b, a); + } + int ColorResolve(int r, int g, int b) { + return gdImageColorResolve(im, r, g, b); + } + int ColorResolve(int r, int g, int b, int a) { + return gdImageColorResolveAlpha(im, r, g, b, a); + } + + void ColorDeallocate(int color) { + gdImageColorDeallocate(im, color); + } + + void TrueColorToPalette(int ditherFlag, int colorsWanted) { + gdImageTrueColorToPalette(im, ditherFlag, colorsWanted); + } + + void ColorTransparent(int color) { + gdImageColorTransparent(im, color); + } + + void PaletteCopy(gdImagePtr src) { + gdImagePaletteCopy(im, src); + } + void PaletteCopy(const GD::Image & src) { + PaletteCopy(src.im); + } + + /** + Write out this image in GIF file format to \p out. + \param out A FILE * handle + */ + void Gif(FILE * out) const { + gdImageGif(im, out); + } + /** + Write out this image in GIF file format to \p out. + \param out A gdIOCtx * handle + */ + void Gif(gdIOCtx * out) const { + gdImageGifCtx(im, out); + } + /** + Allocate sufficient memory, and write this image, in GIF file format, to that memory. + \param size A pointer for the allocated memory + \return A pointer to the allocated memory, containing the image GIF file formatted. Caller is responsible for freeing with gdFree(). + */ + void * Gif(int * size) const { + return gdImageGifPtr(im, size); + } + /** + Write out this image in GIF file format to \p out. + \param out An output stream, already opened. + */ + void Gif(std::ostream & out) const { + ostreamIOCtx _out_ctx(out); + gdImageGifCtx(im, & _out_ctx); + } + +#ifdef HAVE_LIBPNG + /** + Write out this image in PNG file format to \p out. + \param out A FILE * handle + */ + void Png(FILE * out) const { + gdImagePng(im, out); + } + /** + Write out this image in PNG file format to \p out. + \param out A gdIOCtx * handle + */ + void Png(gdIOCtx * out) const { + gdImagePngCtx(im, out); + } + /** + Allocate sufficient memory, and write this image, in PNG file format, to that memory. + \param size A pointer for the allocated memory + \return A pointer to the allocated memory, containing the image PNG file formatted. Caller is responsible for freeing with gdFree(). + */ + void * Png(int * size) const { + return gdImagePngPtr(im, size); + } + /** + Write out this image in PNG file format to \p out. + \param out An output stream, already opened. + */ + void Png(std::ostream & out) const { + ostreamIOCtx _out_ctx(out); + gdImagePngCtx(im, & _out_ctx); + } + /** + Write out this image in PNG file format to \p out. + \param out A FILE * handle + \param level The level of compression: 0 == "no compression", 1 == "compressed as quickly as possible" --> 9 == "compressed as much as possible", -1 == zlib default compression level + */ + void Png(FILE * out, int level) const { + gdImagePngEx(im, out, level); + } + /** + Write out this image in PNG file format to \p out. + \param out A gdIOCtx * handle + \param level The level of compression: 0 == "no compression", 1 == "compressed as quickly as possible" --> 9 == "compressed as much as possible", -1 == zlib default compression level + */ + void Png(gdIOCtx * out, int level) const { + gdImagePngCtxEx(im, out, level); + } + /** + Allocate sufficient memory, and write this image, in PNG file format, to that memory. + \param size A pointer for the allocated memory + \param level The level of compression: 0 == "no compression", 1 == "compressed as quickly as possible" --> 9 == "compressed as much as possible", -1 == zlib default compression level + \return A pointer to the allocated memory, containing the image PNG file formatted. Caller is responsible for freeing with gdFree(). + */ + void * Png(int * size, int level) const { + return gdImagePngPtrEx(im, size, level); + } + /** + Write out this image in PNG file format to \p out. + \param out An output stream, already opened. + \param level The level of compression: 0 == "no compression", 1 == "compressed as quickly as possible" --> 9 == "compressed as much as possible", -1 == zlib default compression level + */ + void Png(std::ostream & out, int level) const { + ostreamIOCtx _out_ctx(out); + gdImagePngCtxEx(im, & _out_ctx, level); + } +#endif + + /** + Write out this image in WBMP file format ( black and white only ) to \p out. + \param fg The color index of the foreground. All other pixels considered background. + \param out A FILE * handle + */ + void WBMP(int fg, FILE * out) const { + gdImageWBMP(im, fg, out); + } + /** + Write out this image in WBMP file format ( black and white only ) to \p out. + \param fg The color index of the foreground. All other pixels considered background. + \param out A gdIOCtx * handle + */ + void WBMP(int fg, gdIOCtx * out) const { + gdImageWBMPCtx(im, fg, out); + } + /** + Allocate sufficient memory, and write this image, in WBMP file format ( black and white only ), to that memory. + \param size A pointer for the allocated memory + \param fg The color index of the foreground. All other pixels considered background. + \return A pointer to the allocated memory, containing the image WBMP file formatted. Caller is responsible for freeing with gdFree(). + */ + void * WBMP(int * size, int fg) const { + return gdImageWBMPPtr(im, size, fg); + } + /** + Write out this image in WBMP file format ( black and white only ) to \p out. + \param fg The color index of the foreground. All other pixels considered background. + \param out An output stream, already opened. + */ + void WBMP(int fg, std::ostream & out) const { + ostreamIOCtx _out_ctx(out); + gdImageWBMPCtx(im, fg, & _out_ctx); + } + +#ifdef HAVE_LIBJPEG + /** + Write out this image in JPEG file format to \p out. + \param out A FILE * handle + \param quality Should be a value in the range 0-95, higher numbers imply both higher quality and larger image size. Default value is -1, indicating "use a sensible default value". + */ + void Jpeg(FILE * out, int quality = -1) const { + gdImageJpeg(im, out, quality); + } + /** + Write out this image in JPEG file format to \p out. + \param out A gdIOCtx * handle + \param quality Should be a value in the range 0-95, higher numbers imply both higher quality and larger image size. Default value is -1, indicating "use a sensible default value". + */ + void Jpeg(gdIOCtx * out, int quality = -1) const { + gdImageJpegCtx(im, out, quality); + } + /** + Allocate sufficient memory, and write this image, in JPEG file format, to that memory. + \param size A pointer for the allocated memory + \param quality Should be a value in the range 0-95, higher numbers imply both higher quality and larger image size. Default value is -1, indicating "use a sensible default value". + \return A pointer to the allocated memory, containing the image JPEG file formatted. Caller is responsible for freeing with gdFree(). + */ + void * Jpeg(int * size, int quality = -1) const { + return gdImageJpegPtr(im, size, quality); + } + /** + Write out this image in JPEG file format to \p out. + \param out An output stream, already opened. + \param quality Should be a value in the range 0-95, higher numbers imply both higher quality and larger image size. Default value is -1, indicating "use a sensible default value". + */ + void Jpeg(std::ostream & out, int quality = -1) const { + ostreamIOCtx _out_ctx(out); + gdImageJpegCtx(im, & _out_ctx, quality); + } +#endif + + void GifAnimBegin(FILE * out, int GlobalCM, int Loops) const { + gdImageGifAnimBegin(im, out, GlobalCM, Loops); + } + void GifAnimAdd(FILE * out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal, gdImagePtr previm) const { + gdImageGifAnimAdd(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm); + } + void GifAnimAdd(FILE * out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal, const GD::Image & previm) const { + GifAnimAdd(out, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm.im); + } + inline static void GifAnimEnd(FILE * out) { + gdImageGifAnimEnd(out); + } + void GifAnimBegin(gdIOCtx * out, int GlobalCM, int Loops) const { + gdImageGifAnimBeginCtx(im, out, GlobalCM, Loops); + } + void GifAnimAdd(gdIOCtx * out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal, gdImagePtr previm) const { + gdImageGifAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm); + } + void GifAnimAdd(gdIOCtx * out, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal, const GD::Image & previm) const { + GifAnimAdd(out, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm.im); + } + inline static void GifAnimEnd(gdIOCtx * out) { + gdImageGifAnimEndCtx(out); + } + void * GifAnimBegin(int * size, int GlobalCM, int Loops) const { + return gdImageGifAnimBeginPtr(im, size, GlobalCM, Loops); + } + void * GifAnimAdd(int * size, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal, gdImagePtr previm) const { + return gdImageGifAnimAddPtr(im, size, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm); + } + void * GifAnimAdd(int * size, int LocalCM, int LeftOfs, int TopOfs, int Delay, int Disposal, const GD::Image & previm) const { + return GifAnimAdd(size, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm.im); + } + inline static void * GifAnimEnd(int * size) { + return gdImageGifAnimEndPtr(size); + } + + void Gd(FILE * out) const { + gdImageGd(im, out); + } + void* Gd(int * size) const { + return gdImageGdPtr(im, size); + } + void Gd2(FILE * out, int cs, int fmt) const { + gdImageGd2(im, out, cs, fmt); + } + void* Gd2(int cs, int fmt, int * size) const { + return gdImageGd2Ptr(im, cs, fmt, size); + } + + void Ellipse(int cx, int cy, int w, int h, int color) { + gdImageEllipse(im, cx, cy, w, h, color); + } + /** + Draw a partial ellipse centered at the given point, with the specified width and height in pixels. + */ + void FilledArc(int cx, int cy, int w, int h, int s, int e, int color, int style) { + gdImageFilledArc(im, cx, cy, w, h, s, e, color, style); + } + void Arc(int cx, int cy, int w, int h, int s, int e, int color) { + gdImageArc(im, cx, cy, w, h, s, e, color); + } + void FilledEllipse(int cx, int cy, int w, int h, int color) { + gdImageFilledEllipse(im, cx, cy, w, h, color); + } + void FillToBorder(int x, int y, int border, int color) { + gdImageFillToBorder(im, x, y, border, color); + } + void Fill(int x, int y, int color) { + gdImageFill(im, x, y, color); + } + + void Ellipse(const Point & c, const Size & s, int color) { + Ellipse(c.X(), c.Y(), s.W(), s.H(), color); + } + void FilledArc(const Point & c, const Size & si, int s, int e, int color, int style) { + FilledArc(c.X(), c.Y(), si.W(), si.H(), s, e, color, style); + } + void Arc(const Point & c, const Size & si, int s, int e, int color) { + Arc(c.X(), c.Y(), si.W(), si.H(), s, e, color); + } + void FilledEllipse(const Point & c, const Size & s, int color) { + FilledEllipse(c.X(), c.Y(), s.W(), s.H(), color); + } + void FillToBorder(const Point & p, int border, int color) { + FillToBorder(p.X(), p.Y(), border, color); + } + void Fill(const Point & p, int color) { + Fill(p.X(), p.Y(), color); + } + + void Copy(const gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h) { + gdImageCopy(im, src, dstX, dstY, srcX, srcY, w, h); + } + void CopyMerge(const gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct) { + gdImageCopyMerge(im, src, dstX, dstY, srcX, srcY, w, h, pct); + } + void CopyMergeGray(const gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct) { + gdImageCopyMergeGray(im, src, dstX, dstY, srcX, srcY, w, h, pct); + } + + void CopyResized(const gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH) { + gdImageCopyResized(im, src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH); + } + void CopyResampled(const gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH) { + gdImageCopyResampled(im, src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH); + } + void CopyRotated(const gdImagePtr src, double dstX, double dstY, int srcX, int srcY, int srcWidth, int srcHeight, int angle) { + gdImageCopyRotated(im, src, dstX, dstY, srcX, srcY, srcWidth, srcHeight, angle); + } + + Image * CopyGaussianBlurred(int radius, double sigma) { + return new Image(gdImageCopyGaussianBlurred(im, radius, sigma)); + } + + void Copy(const gdImagePtr src, const Point & dstP, const Point & srcP, const Size & s) { + Copy(src, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), s.W(), s.H()); + } + void CopyMerge(const gdImagePtr src, const Point & dstP, const Point & srcP, const Size & s, int pct) { + CopyMerge(src, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), s.W(), s.H(), pct); + } + void CopyMergeGray(const gdImagePtr src, const Point & dstP, const Point & srcP, const Size & s, int pct) { + CopyMergeGray(src, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), s.W(), s.H(), pct); + } + + void CopyResized(const gdImagePtr src, const Point & dstP, const Point & srcP, const Size & dstS, const Size & srcS) { + CopyResized(src, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), dstS.W(), dstS.H(), srcS.W(), srcS.H()); + } + void CopyResampled(const gdImagePtr src, const Point & dstP, const Point & srcP, const Size & dstS, const Size & srcS) { + CopyResampled(src, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), dstS.W(), dstS.H(), srcS.W(), srcS.H()); + } + void CopyRotated(const gdImagePtr src, double dstX, double dstY, const Point & srcP, const Size & srcS, int angle) { + CopyRotated(src, dstX, dstY, srcP.X(), srcP.Y(), srcS.W(), srcS.H(), angle); + } + + void Copy(const GD::Image & src, int dstX, int dstY, int srcX, int srcY, int w, int h) { + Copy(src.im, dstX, dstY, srcX, srcY, w, h); + } + void CopyMerge(const GD::Image & src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct) { + CopyMerge(src.im, dstX, dstY, srcX, srcY, w, h, pct); + } + void CopyMergeGray(const GD::Image & src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct) { + CopyMergeGray(src.im, dstX, dstY, srcX, srcY, w, h, pct); + } + + void CopyResized(const GD::Image & src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH) { + CopyResized(src.im, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH); + } + void CopyResampled(const GD::Image & src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH) { + CopyResampled(src.im, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH); + } + void CopyRotated(const GD::Image & src, double dstX, double dstY, int srcX, int srcY, int srcWidth, int srcHeight, int angle) { + CopyRotated(src.im, dstX, dstY, srcX, srcY, srcWidth, srcHeight, angle); + } + + void Copy(const GD::Image & src, const Point & dstP, const Point & srcP, const Size & s) { + Copy(src.im, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), s.W(), s.H()); + } + void CopyMerge(const GD::Image & src, const Point & dstP, const Point & srcP, const Size & s, int pct) { + CopyMerge(src.im, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), s.W(), s.H(), pct); + } + void CopyMergeGray(const GD::Image & src, const Point & dstP, const Point & srcP, const Size & s, int pct) { + CopyMergeGray(src.im, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), s.W(), s.H(), pct); + } + + void CopyResized(const GD::Image & src, const Point & dstP, const Point & srcP, const Size & dstS, const Size & srcS) { + CopyResized(src.im, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), dstS.W(), dstS.H(), srcS.W(), srcS.H()); + } + void CopyResampled(const GD::Image & src, const Point & dstP, const Point & srcP, const Size & dstS, const Size & srcS) { + CopyResampled(src.im, dstP.X(), dstP.Y(), srcP.X(), srcP.Y(), dstS.W(), dstS.H(), srcS.W(), srcS.H()); + } + void CopyRotated(const GD::Image & src, double dstX, double dstY, const Point & srcP, const Size & srcS, int angle) { + CopyRotated(src.im, dstX, dstY, srcP.X(), srcP.Y(), srcS.W(), srcS.H(), angle); + } + + Image * Clone() { + return new Image(gdImageClone(im)); + } + + void SetBrush(gdImagePtr brush) { + gdImageSetBrush(im, brush); + } + void SetBrush(const GD::Image & brush) { + SetBrush(brush.im); + } + void SetTile(gdImagePtr tile) { + gdImageSetTile(im, tile); + } + void SetTile(const GD::Image & tile) { + SetTile(tile.im); + } + void SetAntiAliased(int c) { + gdImageSetAntiAliased(im, c); + } + void SetAntiAliasedDontBlend(int c, int dont_blend) { + gdImageSetAntiAliasedDontBlend(im, c, dont_blend); + } + void SetStyle(int * style, int noOfPixels) { + gdImageSetStyle(im, style, noOfPixels); + } + void SetThickness(int thickness) { + gdImageSetThickness(im, thickness); + } + void SetResolution(int res_x, int res_y) { + gdImageSetResolution(im, res_x, res_y); + } + void SetInterpolationMethod(gdInterpolationMethod interpolation_method) { + gdImageSetInterpolationMethod(im, interpolation_method); + } + + Image * RotateInterpolated(const float angle, int bgcolor) { + return new Image(gdImageRotateInterpolated(im, angle, bgcolor)); + } + + void Interlace(bool interlaceArg) { + gdImageInterlace(im, interlaceArg?1:0); + } + void AlphaBlending(bool alphaBlendingArg) { + gdImageAlphaBlending(im, alphaBlendingArg?1:0); + } + void SaveAlpha(bool saveAlphaArg) { + gdImageSaveAlpha(im, saveAlphaArg?1:0); + } + + int ColorReplace(int src, int dst) { + return gdImageColorReplace(im, src, dst); + } + int ColorReplaceArray(int len, int * src, int * dst) { + return gdImageColorReplaceArray(im, len, src, dst); + } + int ColorReplaceCallback(gdCallbackImageColor callback) { + return gdImageColorReplaceCallback(im, callback); + } + int ColorReplaceThreshold(int src, int dst, float threshold) { + return gdImageColorReplaceThreshold(im, src, dst, threshold); + } + + bool Pixelate(int block_size, gdPixelateMode mode) { + return gdImagePixelate(im, block_size, mode) == 0 ? false : true; + } + + Image * Scale(int new_width, int new_height) { + return new Image(gdImageScale(im, new_width, new_height)); + } + + bool IsTrueColor() const { + return (gdImageTrueColor(im)?true:false); + } + int SX() const { + return gdImageSX(im); + } + int SY() const { + return gdImageSY(im); + } + int Width() const { + return SX(); + } + int Height() const { + return SY(); + } + int ResX() const { + return gdImageResolutionX(im); + } + int ResY() const { + return gdImageResolutionY(im); + } + void GetSize(Size & s) const { + s.set(SX(), SY()); + } + int ColorsTotal() const { + return gdImageColorsTotal(im); + } + int Red(int color) const { + return gdImageRed(im, color); + } + int Green(int color) const { + return gdImageGreen(im, color); + } + int Blue(int color) const { + return gdImageBlue(im, color); + } + int Alpha(int color) const { + return gdImageAlpha(im, color); + } + int GetTransparent() const { + return gdImageGetTransparent(im); + } + int GetInterlaced() const { + return gdImageGetInterlaced(im); + } + int PalettePixel(int x, int y) const { + return gdImagePalettePixel(im, x, y); + } + int TrueColorPixel(int x, int y) const { + return gdImageTrueColorPixel(im, x, y); + } + + const gdImagePtr GetPtr() const { + return im; + } + +protected: + /// Free the internal image pointer + void clear() { + if (im) + gdImageDestroy(im); + im = 0; + } + gdImagePtr im; +}; +} // namespace GD +/// Read in an image from a standard library input stream +std::istream & operator>> (std::istream & in, GD::Image & img); + +#endif /* _gdpp_h */ +#endif /* __cplusplus */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdtables.c b/Build/source/libs/gd/libgd-2.1.1/src/gdtables.c new file mode 100644 index 00000000000..7753b21a4b3 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdtables.c @@ -0,0 +1,726 @@ + +const int gdCosT[] = { + 1024, + 1023, + 1023, + 1022, + 1021, + 1020, + 1018, + 1016, + 1014, + 1011, + 1008, + 1005, + 1001, + 997, + 993, + 989, + 984, + 979, + 973, + 968, + 962, + 955, + 949, + 942, + 935, + 928, + 920, + 912, + 904, + 895, + 886, + 877, + 868, + 858, + 848, + 838, + 828, + 817, + 806, + 795, + 784, + 772, + 760, + 748, + 736, + 724, + 711, + 698, + 685, + 671, + 658, + 644, + 630, + 616, + 601, + 587, + 572, + 557, + 542, + 527, + 512, + 496, + 480, + 464, + 448, + 432, + 416, + 400, + 383, + 366, + 350, + 333, + 316, + 299, + 282, + 265, + 247, + 230, + 212, + 195, + 177, + 160, + 142, + 124, + 107, + 89, + 71, + 53, + 35, + 17, + 0, + -17, + -35, + -53, + -71, + -89, + -107, + -124, + -142, + -160, + -177, + -195, + -212, + -230, + -247, + -265, + -282, + -299, + -316, + -333, + -350, + -366, + -383, + -400, + -416, + -432, + -448, + -464, + -480, + -496, + -512, + -527, + -542, + -557, + -572, + -587, + -601, + -616, + -630, + -644, + -658, + -671, + -685, + -698, + -711, + -724, + -736, + -748, + -760, + -772, + -784, + -795, + -806, + -817, + -828, + -838, + -848, + -858, + -868, + -877, + -886, + -895, + -904, + -912, + -920, + -928, + -935, + -942, + -949, + -955, + -962, + -968, + -973, + -979, + -984, + -989, + -993, + -997, + -1001, + -1005, + -1008, + -1011, + -1014, + -1016, + -1018, + -1020, + -1021, + -1022, + -1023, + -1023, + -1024, + -1023, + -1023, + -1022, + -1021, + -1020, + -1018, + -1016, + -1014, + -1011, + -1008, + -1005, + -1001, + -997, + -993, + -989, + -984, + -979, + -973, + -968, + -962, + -955, + -949, + -942, + -935, + -928, + -920, + -912, + -904, + -895, + -886, + -877, + -868, + -858, + -848, + -838, + -828, + -817, + -806, + -795, + -784, + -772, + -760, + -748, + -736, + -724, + -711, + -698, + -685, + -671, + -658, + -644, + -630, + -616, + -601, + -587, + -572, + -557, + -542, + -527, + -512, + -496, + -480, + -464, + -448, + -432, + -416, + -400, + -383, + -366, + -350, + -333, + -316, + -299, + -282, + -265, + -247, + -230, + -212, + -195, + -177, + -160, + -142, + -124, + -107, + -89, + -71, + -53, + -35, + -17, + 0, + 17, + 35, + 53, + 71, + 89, + 107, + 124, + 142, + 160, + 177, + 195, + 212, + 230, + 247, + 265, + 282, + 299, + 316, + 333, + 350, + 366, + 383, + 400, + 416, + 432, + 448, + 464, + 480, + 496, + 512, + 527, + 542, + 557, + 572, + 587, + 601, + 616, + 630, + 644, + 658, + 671, + 685, + 698, + 711, + 724, + 736, + 748, + 760, + 772, + 784, + 795, + 806, + 817, + 828, + 838, + 848, + 858, + 868, + 877, + 886, + 895, + 904, + 912, + 920, + 928, + 935, + 942, + 949, + 955, + 962, + 968, + 973, + 979, + 984, + 989, + 993, + 997, + 1001, + 1005, + 1008, + 1011, + 1014, + 1016, + 1018, + 1020, + 1021, + 1022, + 1023, + 1023 +}; + +const int gdSinT[] = { + 0, + 17, + 35, + 53, + 71, + 89, + 107, + 124, + 142, + 160, + 177, + 195, + 212, + 230, + 247, + 265, + 282, + 299, + 316, + 333, + 350, + 366, + 383, + 400, + 416, + 432, + 448, + 464, + 480, + 496, + 512, + 527, + 542, + 557, + 572, + 587, + 601, + 616, + 630, + 644, + 658, + 671, + 685, + 698, + 711, + 724, + 736, + 748, + 760, + 772, + 784, + 795, + 806, + 817, + 828, + 838, + 848, + 858, + 868, + 877, + 886, + 895, + 904, + 912, + 920, + 928, + 935, + 942, + 949, + 955, + 962, + 968, + 973, + 979, + 984, + 989, + 993, + 997, + 1001, + 1005, + 1008, + 1011, + 1014, + 1016, + 1018, + 1020, + 1021, + 1022, + 1023, + 1023, + 1024, + 1023, + 1023, + 1022, + 1021, + 1020, + 1018, + 1016, + 1014, + 1011, + 1008, + 1005, + 1001, + 997, + 993, + 989, + 984, + 979, + 973, + 968, + 962, + 955, + 949, + 942, + 935, + 928, + 920, + 912, + 904, + 895, + 886, + 877, + 868, + 858, + 848, + 838, + 828, + 817, + 806, + 795, + 784, + 772, + 760, + 748, + 736, + 724, + 711, + 698, + 685, + 671, + 658, + 644, + 630, + 616, + 601, + 587, + 572, + 557, + 542, + 527, + 512, + 496, + 480, + 464, + 448, + 432, + 416, + 400, + 383, + 366, + 350, + 333, + 316, + 299, + 282, + 265, + 247, + 230, + 212, + 195, + 177, + 160, + 142, + 124, + 107, + 89, + 71, + 53, + 35, + 17, + 0, + -17, + -35, + -53, + -71, + -89, + -107, + -124, + -142, + -160, + -177, + -195, + -212, + -230, + -247, + -265, + -282, + -299, + -316, + -333, + -350, + -366, + -383, + -400, + -416, + -432, + -448, + -464, + -480, + -496, + -512, + -527, + -542, + -557, + -572, + -587, + -601, + -616, + -630, + -644, + -658, + -671, + -685, + -698, + -711, + -724, + -736, + -748, + -760, + -772, + -784, + -795, + -806, + -817, + -828, + -838, + -848, + -858, + -868, + -877, + -886, + -895, + -904, + -912, + -920, + -928, + -935, + -942, + -949, + -955, + -962, + -968, + -973, + -979, + -984, + -989, + -993, + -997, + -1001, + -1005, + -1008, + -1011, + -1014, + -1016, + -1018, + -1020, + -1021, + -1022, + -1023, + -1023, + -1024, + -1023, + -1023, + -1022, + -1021, + -1020, + -1018, + -1016, + -1014, + -1011, + -1008, + -1005, + -1001, + -997, + -993, + -989, + -984, + -979, + -973, + -968, + -962, + -955, + -949, + -942, + -935, + -928, + -920, + -912, + -904, + -895, + -886, + -877, + -868, + -858, + -848, + -838, + -828, + -817, + -806, + -795, + -784, + -772, + -760, + -748, + -736, + -724, + -711, + -698, + -685, + -671, + -658, + -644, + -630, + -616, + -601, + -587, + -572, + -557, + -542, + -527, + -512, + -496, + -480, + -464, + -448, + -432, + -416, + -400, + -383, + -366, + -350, + -333, + -316, + -299, + -282, + -265, + -247, + -230, + -212, + -195, + -177, + -160, + -142, + -124, + -107, + -89, + -71, + -53, + -35, + -17 +}; diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdtest.c b/Build/source/libs/gd/libgd-2.1.1/src/gdtest.c new file mode 100644 index 00000000000..17dfc1bc521 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdtest.c @@ -0,0 +1,395 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#ifdef _WIN32 +#include <process.h> +int +unlink (const char *filename) +{ + return _unlink (filename); +} +#else +#include <unistd.h> /* for getpid(), unlink() */ +#endif +#include "gd.h" + +void CompareImages (char *msg, gdImagePtr im1, gdImagePtr im2); + +static int freadWrapper (void *context, char *buf, int len); +static int fwriteWrapper (void *context, const char *buffer, int len); + +int +main (int argc, char **argv) +{ +#ifdef HAVE_LIBPNG + gdImagePtr im, ref, im2, im3; + FILE *in, *out; + void *iptr; + int sz; + char of[256]; + int colRed, colBlu; + gdSource imgsrc; + gdSink imgsnk; + int foreground; + int i; + if (argc != 2) { + fprintf(stderr, "Usage: gdtest filename.png\n"); + exit (1); + } + in = fopen (argv[1], "rb"); + if (!in) { + fprintf(stderr, "Input file does not exist!\n"); + exit (1); + } + im = gdImageCreateFromPng (in); + + rewind (in); + ref = gdImageCreateFromPng (in); + + fclose (in); + + printf ("Reference File has %d Palette entries\n", ref->colorsTotal); + + CompareImages ("Initial Versions", ref, im); + + + /* */ + /* Send to PNG File then Ptr */ + /* */ +#ifdef VMS + sprintf (of, "%s-png", argv[1]); +#else + sprintf (of, "%s.png", argv[1]); +#endif + out = fopen (of, "wb"); + gdImagePng (im, out); + fclose (out); + + in = fopen (of, "rb"); + if (!in) { + fprintf(stderr, "PNG Output file does not exist!\n"); + exit (1); + } + im2 = gdImageCreateFromPng (in); + fclose (in); + + CompareImages ("GD->PNG File->GD", ref, im2); + + unlink (of); + gdImageDestroy (im2); + + /* 2.0.21: use the new From*Ptr functions */ + iptr = gdImagePngPtr (im, &sz); + im2 = gdImageCreateFromPngPtr (sz, iptr); + gdFree (iptr); + CompareImages ("GD->PNG ptr->GD", ref, im2); + + gdImageDestroy (im2); + + /* */ + /* Send to GD2 File then Ptr */ + /* */ +#ifdef VMS + sprintf (of, "%s-gd2", argv[1]); +#else + sprintf (of, "%s.gd2", argv[1]); +#endif + out = fopen (of, "wb"); + gdImageGd2 (im, out, 128, 2); + fclose (out); + + in = fopen (of, "rb"); + if (!in) { + fprintf(stderr, "GD2 Output file does not exist!\n"); + exit (1); + } + im2 = gdImageCreateFromGd2 (in); + fclose (in); + + CompareImages ("GD->GD2 File->GD", ref, im2); + + unlink (of); + gdImageDestroy (im2); + + iptr = gdImageGd2Ptr (im, 128, 2, &sz); + /*printf("Got ptr %d (size %d)\n",iptr, sz); */ + im2 = gdImageCreateFromGd2Ptr (sz, iptr); + gdFree (iptr); + /*printf("Got img2 %d\n",im2); */ + + CompareImages ("GD->GD2 ptr->GD", ref, im2); + + gdImageDestroy (im2); + + /* */ + /* Send to GD File then Ptr */ + /* */ +#ifdef VMS + sprintf (of, "%s-gd", argv[1]); +#else + sprintf (of, "%s.gd", argv[1]); +#endif + out = fopen (of, "wb"); + gdImageGd (im, out); + fclose (out); + + in = fopen (of, "rb"); + if (!in) { + fprintf(stderr, "GD Output file does not exist!\n"); + exit (1); + } + im2 = gdImageCreateFromGd (in); + fclose (in); + + CompareImages ("GD->GD File->GD", ref, im2); + + unlink (of); + gdImageDestroy (im2); + + iptr = gdImageGdPtr (im, &sz); + /*printf("Got ptr %d (size %d)\n",iptr, sz); */ + im2 = gdImageCreateFromGdPtr (sz, iptr); + gdFree (iptr); + /*printf("Got img2 %d\n",im2); */ + + CompareImages ("GD->GD ptr->GD", ref, im2); + + gdImageDestroy (im2); + + /* + * Test gdImageCreateFromPngSource' + */ + + in = fopen (argv[1], "rb"); + + imgsrc.source = freadWrapper; + imgsrc.context = in; + im2 = gdImageCreateFromPngSource (&imgsrc); + fclose (in); + + if (im2 == NULL) { + printf + ("GD Source: ERROR Null returned by gdImageCreateFromPngSource\n"); + } else { + CompareImages ("GD Source", ref, im2); + gdImageDestroy (im2); + }; + + + /* + * Test gdImagePngToSink' + */ +#ifdef VMS + sprintf (of, "%s-snk", argv[1]); +#else + sprintf (of, "%s.snk", argv[1]); +#endif + out = fopen (of, "wb"); + imgsnk.sink = fwriteWrapper; + imgsnk.context = out; + gdImagePngToSink (im, &imgsnk); + fclose (out); + in = fopen (of, "rb"); + if (!in) { + fprintf (stderr, + "GD Sink: ERROR - GD Sink Output file does not exist!\n"); + } else { + im2 = gdImageCreateFromPng (in); + fclose (in); + + CompareImages ("GD Sink", ref, im2); + gdImageDestroy (im2); + }; + + unlink (of); + + /* */ + /* Test Extraction */ + /* */ + in = fopen ("test/gdtest_200_300_150_100.png", "rb"); + if (!in) { + fprintf(stderr, "gdtest_200_300_150_100.png does not exist!\n"); + exit (1); + } + im2 = gdImageCreateFromPng (in); + fclose (in); + + + in = fopen ("test/gdtest.gd2", "rb"); + if (!in) { + fprintf(stderr, "gdtest.gd2 does not exist!\n"); + exit (1); + } + im3 = gdImageCreateFromGd2Part (in, 200, 300, 150, 100); + fclose (in); + + CompareImages ("GD2Part (gdtest_200_300_150_100.png, gdtest.gd2(part))", + im2, im3); + + gdImageDestroy (im2); + gdImageDestroy (im3); + + /* */ + /* Copy Blend */ + /* */ + in = fopen ("test/gdtest.png", "rb"); + if (!in) { + fprintf(stderr, "gdtest.png does not exist!\n"); + exit (1); + } + im2 = gdImageCreateFromPng (in); + fclose (in); + + im3 = gdImageCreate (100, 60); + colRed = gdImageColorAllocate (im3, 255, 0, 0); + colBlu = gdImageColorAllocate (im3, 0, 0, 255); + gdImageFilledRectangle (im3, 0, 0, 49, 30, colRed); + gdImageFilledRectangle (im3, 50, 30, 99, 59, colBlu); + + gdImageCopyMerge (im2, im3, 150, 200, 10, 10, 90, 50, 50); + gdImageCopyMerge (im2, im3, 180, 70, 10, 10, 90, 50, 50); + + gdImageCopyMergeGray (im2, im3, 250, 160, 10, 10, 90, 50, 50); + gdImageCopyMergeGray (im2, im3, 80, 70, 10, 10, 90, 50, 50); + + gdImageDestroy (im3); + + in = fopen ("test/gdtest_merge.png", "rb"); + if (!in) { + fprintf(stderr, "gdtest_merge.png does not exist!\n"); + exit (1); + } + im3 = gdImageCreateFromPng (in); + fclose (in); + + printf ("[Merged Image has %d colours]\n", im2->colorsTotal); + CompareImages ("Merged (gdtest.png, gdtest_merge.png)", im2, im3); + + gdImageDestroy (im2); + gdImageDestroy (im3); + +#ifdef HAVE_LIBJPEG + out = fopen ("test/gdtest.jpg", "wb"); + if (!out) { + fprintf(stderr, "Can't create file test/gdtest.jpg.\n"); + exit (1); + } + gdImageJpeg (im, out, -1); + fclose (out); + in = fopen ("test/gdtest.jpg", "rb"); + if (!in) { + fprintf(stderr, "Can't open file test/gdtest.jpg.\n"); + exit (1); + } + im2 = gdImageCreateFromJpeg (in); + fclose (in); + if (!im2) { + fprintf(stderr, "gdImageCreateFromJpeg failed.\n"); + exit (1); + } + gdImageDestroy (im2); + printf ("Created test/gdtest.jpg successfully. Compare this image\n" + "to the input image manually. Some difference must be\n" + "expected as JPEG is a lossy file format.\n"); +#endif /* HAVE_LIBJPEG */ + /* Assume the color closest to black is the foreground + color for the B&W wbmp image. */ + fprintf (stderr, + "NOTE: the WBMP output image will NOT match the original unless the original\n" + "is also black and white. This is OK!\n"); + foreground = gdImageColorClosest (im, 0, 0, 0); + fprintf(stderr, "Foreground index is %d\n", foreground); + if (foreground == -1) { + fprintf(stderr, "Source image has no colors, skipping wbmp test.\n"); + } else { + out = fopen ("test/gdtest.wbmp", "wb"); + if (!out) { + fprintf(stderr, "Can't create file test/gdtest.wbmp.\n"); + exit (1); + } + gdImageWBMP (im, foreground, out); + fclose (out); + in = fopen ("test/gdtest.wbmp", "rb"); + if (!in) { + fprintf(stderr, "Can't open file test/gdtest.wbmp.\n"); + exit (1); + } + im2 = gdImageCreateFromWBMP (in); + fprintf(stderr, "WBMP has %d colors\n", gdImageColorsTotal (im2)); + fprintf(stderr, "WBMP colors are:\n"); + for (i = 0; (i < gdImageColorsTotal (im2)); i++) { + fprintf(stderr, "%02X%02X%02X\n", + gdImageRed (im2, i), + gdImageGreen (im2, i), gdImageBlue (im2, i)); + } + fclose (in); + if (!im2) { + fprintf(stderr, "gdImageCreateFromWBMP failed.\n"); + exit (1); + } + CompareImages ("WBMP test (gdtest.png, gdtest.wbmp)", ref, im2); + out = fopen ("test/gdtest_wbmp_to_png.png", "wb"); + if (!out) { + fprintf (stderr, + "Can't create file test/gdtest_wbmp_to_png.png.\n"); + exit (1); + } + gdImagePng (im2, out); + fclose (out); + gdImageDestroy (im2); + } + gdImageDestroy (im); + gdImageDestroy (ref); +#else + fprintf(stderr, "No PNG library support.\n"); +#endif /* HAVE_LIBPNG */ + + return 0; +} + +void +CompareImages (char *msg, gdImagePtr im1, gdImagePtr im2) +{ + int cmpRes; + + cmpRes = gdImageCompare (im1, im2); + + if (cmpRes & GD_CMP_IMAGE) { + printf ("%%%s: ERROR images differ: BAD\n", msg); + } else if (cmpRes != 0) { + printf ("%%%s: WARNING images differ: WARNING - Probably OK\n", msg); + } else { + printf ("%%%s: OK\n", msg); + return; + } + + if (cmpRes & (GD_CMP_SIZE_X + GD_CMP_SIZE_Y)) { + printf ("-%s: INFO image sizes differ\n", msg); + } + + if (cmpRes & GD_CMP_NUM_COLORS) { + printf ("-%s: INFO number of palette entries differ %d Vs. %d\n", msg, + im1->colorsTotal, im2->colorsTotal); + } + + if (cmpRes & GD_CMP_COLOR) { + printf ("-%s: INFO actual colours of pixels differ\n", msg); + } +} + + +static int +freadWrapper (void *context, char *buf, int len) +{ + int got = fread (buf, 1, len, (FILE *) context); + return got; +} + +static int +fwriteWrapper (void *context, const char *buffer, int len) +{ + return fwrite (buffer, 1, len, (FILE *) context); +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdtestft.c b/Build/source/libs/gd/libgd-2.1.1/src/gdtestft.c new file mode 100644 index 00000000000..e72165bdb56 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdtestft.c @@ -0,0 +1,190 @@ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gd.h" +#include <string.h> +#include <stdlib.h> + +#define PI 3.141592 +#define DEG2RAD(x) ((x)*PI/180.) + +#define MAX(x,y) ((x) > (y) ? (x) : (y)) +#define MIN(x,y) ((x) < (y) ? (x) : (y)) + +#define MAX4(x,y,z,w) \ + ((MAX((x),(y))) > (MAX((z),(w))) ? (MAX((x),(y))) : (MAX((z),(w)))) +#define MIN4(x,y,z,w) \ + ((MIN((x),(y))) < (MIN((z),(w))) ? (MIN((x),(y))) : (MIN((z),(w)))) + +#define MAXX(x) MAX4(x[0],x[2],x[4],x[6]) +#define MINX(x) MIN4(x[0],x[2],x[4],x[6]) +#define MAXY(x) MAX4(x[1],x[3],x[5],x[7]) +#define MINY(x) MIN4(x[1],x[3],x[5],x[7]) + +int +main (int argc, char *argv[]) +{ +#ifndef HAVE_LIBFREETYPE + fprintf(stderr, "gd was not compiled with HAVE_LIBFREETYPE defined.\n"); + fprintf(stderr, "Install the FreeType library, including the\n"); + fprintf(stderr, "header files. Then edit the gd Makefile, type\n"); + fprintf(stderr, "make clean, and type make again.\n"); + return 1; +#else + gdImagePtr im; + int blue; + int blueAlpha; + int white; + int brect[8]; + int x, y, sx, sy; + char *err; + FILE *out; +#ifdef JISX0208 + char *s = "Hello. ‚±‚ñ‚É‚¿‚Í Qyjpqg,"; /* String to draw. */ +#else + char *s = "Hello. äöü Qyjpqg,"; /* String to draw. */ +#endif + + double sz = 40.; + +#if 0 + double angle = 0.; +#else + double angle = DEG2RAD (90); +#endif + char *f; + if (argc == 2) { + f = argv[1]; + } else { + /* 2.02: usage message. Defaulting to Times wasn't working well for the + many people with no /usr/share/fonts/truetype. */ + fprintf(stderr, "Usage: gdtestft fontfilename\n" + "If fontfilename is not a full or relative path, GDFONTPATH is searched for\n" + "it. If GDFONTPATH is not set, /usr/share/fonts/truetype is searched.\n"); + return 1; + } + /* obtain brect so that we can size the image */ + err = + gdImageStringFT ((gdImagePtr) NULL, &brect[0], 0, f, sz, angle, 0, 0, s); + if (err) { + fprintf(stderr, "%s\n", err); + return 1; + } + + /* create an image just big enough for the string (x3) */ + sx = MAXX (brect) - MINX (brect) + 6; + sy = MAXY (brect) - MINY (brect) + 6; +#if 0 + /* Would be palette color 8-bit (which of course is still allowed, + but not impressive when used with a JPEG background and antialiasing + and alpha channel and so on!) */ + im = gdImageCreate (sx * 3, sy); +#else + /* gd 2.0: true color images can use freetype too, + and they can do antialiasing against arbitrary + complex backgrounds. */ + im = gdImageCreateTrueColor (sx * 3, sy); +#endif + /* Background color. gd 2.0: fill the image with it; truecolor + images have a black background otherwise. */ + white = gdImageColorResolve (im, 255, 255, 255); + /* Load a pretty background and resample it to cover the entire image */ + { + FILE *in = fopen ("eleanor.jpg", "rb"); + gdImagePtr imb = NULL; + if (in) { +#ifdef HAVE_LIBJPEG + imb = gdImageCreateFromJpeg (in); +#else + fprintf(stderr, "No JPEG library support.\n"); +#endif + fclose(in); + + if (!imb) { + fprintf(stderr, "gdImageCreateFromJpeg failed\n"); + return 1; + } + if (!im->trueColor) { + /* If destination is not truecolor, convert the JPEG to a + reasonably high-quality palette version. This is not as good + as creating a truecolor output file, of course. Leave many + colors for text smoothing. */ +#if 1 + gdImageTrueColorToPalette (imb, 0, 128); +#endif + } + /* Resample background image to cover new image exactly */ + gdImageCopyResampled (im, imb, 0, 0, 0, 0, sx * 3, sy, + gdImageSX (imb), gdImageSY (imb)); + } else { + /* Can't get background, so paint a simple one */ + /* Truecolor images start out black, so paint it white */ + gdImageFilledRectangle (im, 0, 0, sx * 3, sy, white); + } + } + /* TBB 2.0.2: only black was working, and I didn't know it because + the test program used black. Funny, huh? Let's do a more interesting + color this time. */ + blue = gdImageColorResolve (im, 128, 192, 255); + /* Almost-transparent blue (alpha blending), with antialiasing */ + blueAlpha = gdImageColorResolveAlpha (im, 128, 192, 255, gdAlphaMax / 2); + /* render the string, offset origin to center string */ + x = 0 - MINX (brect) + 3; + y = 0 - MINY (brect) + 3; + + /* With antialiasing (positive color value) */ + err = gdImageStringFT (im, NULL, blue, f, sz, angle, x, y, s); + if (err) { + fprintf(stderr, "%s\n", err); + return 1; + } + /* Without antialiasing (negative color value) */ + err = gdImageStringFT (im, NULL, -blue, f, sz, angle, sx + x, y, s); + if (err) { + fprintf(stderr, "%s\n", err); + return 1; + } + /* With antialiasing, and 50% alpha blending (truecolor only) */ + err = gdImageStringFT (im, NULL, blueAlpha, f, sz, angle, sx * 2 + x, y, s); + if (err) { + fprintf(stderr, "%s\n", err); + return 1; + } + /* TBB: Write img to test/fttest.jpg or test/fttest.png */ + if (im->trueColor) { +#ifdef HAVE_LIBJPEG + out = fopen ("test/fttest.jpg", "wb"); + if (!out) { + fprintf(stderr, "Can't create test/fttest.jpg\n"); + exit (1); + } + /* Fairly high JPEG quality setting */ + gdImageJpeg (im, out, 90); + fclose (out); + fprintf(stderr, "Test image written to test/fttest.jpg\n"); +#else + fprintf(stderr, "Test image not written; No JPEG library support.\n"); +#endif + } else { +#ifdef HAVE_LIBPNG + out = fopen ("test/fttest.png", "wb"); + if (!out) { + fprintf(stderr, "Can't create test/fttest.png\n"); + exit (1); + } + /* 2.0.10: correct ifdef, thanks to Gabriele Verzeletti */ + gdImagePng (im, out); + fclose (out); + fprintf(stderr, "Test image written to test/fttest.png\n"); +#else + fprintf(stderr, "Test image not written; No PNG library support.\n"); +#endif + } + /* Destroy it */ + gdImageDestroy (im); + + return 0; +#endif /* HAVE_LIBFREETYPE */ +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdtopng.c b/Build/source/libs/gd/libgd-2.1.1/src/gdtopng.c new file mode 100644 index 00000000000..d3341b43cad --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdtopng.c @@ -0,0 +1,50 @@ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include "gd.h" + +/* A short program which converts a .png file into a .gd file, for + your convenience in creating images on the fly from a + basis image that must be loaded quickly. The .gd format + is not intended to be a general-purpose format. */ + +int +main (int argc, char **argv) +{ + gdImagePtr im; + FILE *in, *out; + if (argc != 3) { + fprintf(stderr, "Usage: gdtopng filename.gd filename.png\n"); + exit (1); + } + in = fopen (argv[1], "rb"); + if (!in) { + fprintf(stderr, "Input file does not exist!\n"); + exit (1); + } + im = gdImageCreateFromGd (in); + fclose (in); + if (!im) { + fprintf(stderr, "Input is not in GD format!\n"); + exit (1); + } + out = fopen (argv[2], "wb"); + if (!out) { + fprintf(stderr, "Output file cannot be written to!\n"); + gdImageDestroy (im); + exit (1); + } +#ifdef HAVE_LIBPNG + gdImagePng (im, out); +#else + fprintf(stderr, "No PNG library support.\n"); +#endif + fclose (out); + gdImageDestroy (im); + + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gdxpm.c b/Build/source/libs/gd/libgd-2.1.1/src/gdxpm.c new file mode 100644 index 00000000000..15603a6bd84 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gdxpm.c @@ -0,0 +1,214 @@ +/* + * Add ability to load xpm files to gd, requires the xpm + * library. + * Caolan.McNamara@ul.ie + * http://www.csn.ul.ie/~caolan + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "gd.h" +#include "gdhelpers.h" +#include "gd_color_map.h" +#include "gd_errors.h" + +#ifndef HAVE_LIBXPM +BGD_DECLARE(gdImagePtr) gdImageCreateFromXpm(char *filename) +{ + (void)filename; + gd_error_ex(GD_ERROR, "libgd was not built with xpm support\n"); + return NULL; +} +#else + +#include <X11/xpm.h> + +/* + Function: gdImageCreateFromXpm + + <gdImageCreateFromXbm> is called to load images from XPM X Window + System color bitmap format files. This function is available only + if HAVE_XPM is selected in the Makefile and the Xpm library is + linked with the application. Unlike most gd file functions, the + Xpm functions *require filenames*, not file + pointers. <gdImageCreateFromXpm> returns a <gdImagePtr> to the new + image, or NULL if unable to load the image (most often because the + file is corrupt or does not contain an XPM bitmap format + image). You can inspect the sx and sy members of the image to + determine its size. The image must eventually be destroyed using + <gdImageDestroy>. + + Parameters: + + filename - The input filename (*not* FILE pointer) + + Returns: + + A pointer to the new image or NULL if an error occurred. + + Example: + + > gdImagePtr im; + > FILE *in; + > in = fopen("myxpm.xpm", "rb"); + > im = gdImageCreateFromXpm(in); + > fclose(in); + > // ... Use the image ... + > gdImageDestroy(im); + +*/ +BGD_DECLARE(gdImagePtr) gdImageCreateFromXpm(char *filename) +{ + XpmInfo info; + XpmImage image; + unsigned int i, j, k, number, len; + char buf[5]; + gdImagePtr im = 0; + int *pointer; + int red = 0, green = 0, blue = 0; + int *colors; + int ret; + + ret = XpmReadFileToXpmImage(filename, &image, &info); + if(ret != XpmSuccess) { + return 0; + } + + number = image.ncolors; + if(overflow2(sizeof(int), number)) { + goto done; + } + for(i = 0; i < number; i++) { + /* + avoid NULL pointer dereference + TODO better fix need to manage monochrome/monovisual + see m_color or g4_color or g_color + */ + if (!image.colorTable[i].c_color) { + goto done; + } + } + + colors = (int *)gdMalloc(sizeof(int) * number); + if(colors == NULL) { + goto done; + } + + if(!(im = gdImageCreate(image.width, image.height))) { + gdFree(colors); + goto done; + } + + for(i = 0; i < number; i++) { + char *c_color = image.colorTable[i].c_color; + if(strcmp(c_color, "None") == 0) { + colors[i] = gdImageGetTransparent(im); + if(colors[i] == -1) colors[i] = gdImageColorAllocate(im, 0, 0, 0); + if(colors[i] != -1) gdImageColorTransparent(im, colors[i]); + continue; + } + len = strlen(c_color); + if(len < 1) continue; + if(c_color[0] == '#') { + switch(len) { + case 4: + buf[2] = '\0'; + buf[0] = buf[1] = c_color[1]; + red = strtol(buf, NULL, 16); + + buf[0] = buf[1] = c_color[2]; + green = strtol(buf, NULL, 16); + + buf[0] = buf[1] = c_color[3]; + blue = strtol(buf, NULL, 16); + break; + + case 7: + buf[2] = '\0'; + buf[0] = c_color[1]; + buf[1] = c_color[2]; + red = strtol(buf, NULL, 16); + + buf[0] = c_color[3]; + buf[1] = c_color[4]; + green = strtol(buf, NULL, 16); + + buf[0] = c_color[5]; + buf[1] = c_color[6]; + blue = strtol(buf, NULL, 16); + break; + + case 10: + buf[3] = '\0'; + buf[0] = c_color[1]; + buf[1] = c_color[2]; + buf[2] = c_color[3]; + red = strtol(buf, NULL, 16); + red /= 64; + + buf[0] = c_color[4]; + buf[1] = c_color[5]; + buf[2] = c_color[6]; + green = strtol(buf, NULL, 16); + green /= 64; + + buf[0] = c_color[7]; + buf[1] = c_color[8]; + buf[2] = c_color[9]; + blue = strtol(buf, NULL, 16); + blue /= 64; + break; + + case 13: + buf[4] = '\0'; + buf[0] = c_color[1]; + buf[1] = c_color[2]; + buf[2] = c_color[3]; + buf[3] = c_color[4]; + red = strtol(buf, NULL, 16); + red /= 256; + + buf[0] = c_color[5]; + buf[1] = c_color[6]; + buf[2] = c_color[7]; + buf[3] = c_color[8]; + green = strtol(buf, NULL, 16); + green /= 256; + + buf[0] = c_color[9]; + buf[1] = c_color[10]; + buf[2] = c_color[11]; + buf[3] = c_color[12]; + blue = strtol(buf, NULL, 16); + blue /= 256; + break; + } + } else if(!gdColorMapLookup(GD_COLOR_MAP_X11, c_color, &red, &green, &blue)) { + continue; + } + + colors[i] = gdImageColorResolve(im, red, green, blue); + } + + pointer = (int *)image.data; + + for(i = 0; i < image.height; i++) { + for(j = 0; j < image.width; j++) { + k = *pointer++; + gdImageSetPixel(im, j, i, colors[k]); + } + } + + gdFree(colors); + +done: + XpmFreeXpmImage(&image); + XpmFreeXpmInfo(&info); + return im; +} +#endif /* HAVE_LIBXPM */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/gifanimtest.c b/Build/source/libs/gd/libgd-2.1.1/src/gifanimtest.c new file mode 100644 index 00000000000..da17b9e24f5 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/gifanimtest.c @@ -0,0 +1,35 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gd.h" + +int main(void) +{ + gdImagePtr im; + gdImagePtr last, cim; + int blue; + FILE *out; + int i; + im = gdImageCreate(100, 100); + blue = gdImageColorAllocate(im, 0, 0, 255); + out = fopen("gifanim.gif", "wb"); + gdImageGifAnimBegin(im, out, 1, 10); + last = 0; + for (i = 0; (i <= 100); i += 2) { + cim = gdImageCreate(100, 100); + gdImagePaletteCopy(cim, im); + gdImageArc(cim, 50, 50, i, i, 0, 360, blue); + gdImageGifAnimAdd(cim, out, 0, 0, 0, 10, gdDisposalNone, last); + if (last) { + gdImageDestroy(last); + } + last = cim; + } + gdImageDestroy(last); + gdImageGifAnimEnd(out); + fclose(out); + gdImageDestroy(im); + return 0; +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/giftogd2.c b/Build/source/libs/gd/libgd-2.1.1/src/giftogd2.c new file mode 100644 index 00000000000..e7d0c6b8250 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/giftogd2.c @@ -0,0 +1,52 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif /* HAVE_CONFIG_H */ + +#include <stdio.h> +#include <stdlib.h> + +#include "gd.h" + +/* A short program which converts a .gif file into a .gd file, for + your convenience in creating images on the fly from a + basis image that must be loaded quickly. The .gd format + is not intended to be a general-purpose format. */ + +int main(int argc, char **argv) +{ + gdImagePtr im; + FILE *in, *out; + int cs, fmt; + + if (argc != 5) { + fprintf(stderr, "Usage: giftogd2 filename.gif filename.gd2 cs fmt\n"); + fprintf(stderr, " where cs is the chunk size\n"); + fprintf(stderr, " fmt is 1 for raw, 2 for compressed\n"); + exit(1); + } + in = fopen(argv[1], "rb"); + if (!in) { + fprintf(stderr, "Input file does not exist!\n"); + exit(1); + } + im = gdImageCreateFromGif(in); + fclose(in); + if (!im) { + fprintf(stderr, "Input is not in GIF format!\n"); + exit(1); + } + out = fopen(argv[2], "wb"); + if (!out) { + fprintf(stderr, "Output file cannot be written to!\n"); + gdImageDestroy(im); + exit(1); + } + cs = atoi(argv[3]); + fmt = atoi(argv[4]); + gdImageGd2(im, out, cs, fmt); + fclose(out); + gdImageDestroy(im); + + return 0; +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/src/jisx0208.h b/Build/source/libs/gd/libgd-2.1.1/src/jisx0208.h new file mode 100644 index 00000000000..d49dddc010a --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/jisx0208.h @@ -0,0 +1,1306 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef JISX0208_H +#define JISX0208_H + /* This file was derived from "src/VF_Ftype.c" in VFlib2-2.24.2 + by Dr. Kakugawa */ + + /* JIS -> Unicode mapping table */ + static const unsigned short UnicodeTbl[][94] = { + { /* category 01 */ + 0x0000, 0x3001, 0x3002, 0xFF0C, 0xFF0E, 0x30FB, 0xFF1A, 0xFF1B, + 0xFF1F, 0xFF01, 0x309B, 0x309C, 0x00B4, 0xFF40, 0x00A8, 0xFF3E, + 0xFFE3, 0xFF3F, 0x30FD, 0x30FE, 0x309D, 0x309E, 0x3003, 0x4EDD, + 0x3005, 0x3006, 0x3007, 0x30FC, 0x2015, 0x2010, 0xFF0F, 0xFF3C, + 0xFF5E, 0x2225, 0xFF5C, 0x2026, 0x2025, 0x2018, 0x2019, 0x201C, + 0x201D, 0xFF08, 0xFF09, 0x3014, 0x3015, 0xFF3B, 0xFF3D, 0xFF5B, + 0xFF5D, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C, 0x300D, 0x300E, + 0x300F, 0x3010, 0x3011, 0xFF0B, 0xFF0D, 0x00B1, 0x00D7, 0x00F7, + 0xFF1D, 0x2260, 0xFF1C, 0xFF1E, 0x2266, 0x2267, 0x221E, 0x2234, + 0x2642, 0x2640, 0x00B0, 0x2032, 0x2033, 0x2103, 0xFFE5, 0xFF04, + 0xFFE0, 0xFFE1, 0xFF05, 0xFF03, 0xFF06, 0xFF0A, 0xFF20, 0x00A7, + 0x2606, 0x2605, 0x25CB, 0x25CF, 0x25CE, 0x25C7 + }, + { /* category 02 */ + 0x25C6, 0x25A1, 0x25A0, 0x25B3, 0x25B2, 0x25BD, 0x25BC, 0x203B, + 0x3012, 0x2192, 0x2190, 0x2191, 0x2193, 0x3013, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x2208, 0x220B, 0x2286, 0x2287, 0x2282, 0x2283, 0x222A, + 0x2229, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x2227, 0x2228, 0xFFE2, 0x21D2, 0x21D4, 0x2200, 0x2203, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x2220, 0x22A5, 0x2312, 0x2202, 0x2207, + 0x2261, 0x2252, 0x226A, 0x226B, 0x221A, 0x223D, 0x221D, 0x2235, + 0x222B, 0x222C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x212B, 0x2030, 0x266F, 0x266D, 0x266A, 0x2020, 0x2021, /**/ + 0x00B6, 0x0000, 0x0000, 0x0000, 0x0000, 0x25EF + }, + { /* category 03 */ + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFF10, + 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18, + 0xFF19, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28, + 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, + 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, + 0xFF39, 0xFF3A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, + 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50, + 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, + 0xFF59, 0xFF5A, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 04 */ + 0x3041, 0x3042, 0x3043, 0x3044, 0x3045, 0x3046, 0x3047, 0x3048, + 0x3049, 0x304A, 0x304B, 0x304C, 0x304D, 0x304E, 0x304F, 0x3050, + 0x3051, 0x3052, 0x3053, 0x3054, 0x3055, 0x3056, 0x3057, 0x3058, + 0x3059, 0x305A, 0x305B, 0x305C, 0x305D, 0x305E, 0x305F, 0x3060, + 0x3061, 0x3062, 0x3063, 0x3064, 0x3065, 0x3066, 0x3067, 0x3068, + 0x3069, 0x306A, 0x306B, 0x306C, 0x306D, 0x306E, 0x306F, 0x3070, + 0x3071, 0x3072, 0x3073, 0x3074, 0x3075, 0x3076, 0x3077, 0x3078, + 0x3079, 0x307A, 0x307B, 0x307C, 0x307D, 0x307E, 0x307F, 0x3080, + 0x3081, 0x3082, 0x3083, 0x3084, 0x3085, 0x3086, 0x3087, 0x3088, + 0x3089, 0x308A, 0x308B, 0x308C, 0x308D, 0x308E, 0x308F, 0x3090, + 0x3091, 0x3092, 0x3093, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 05 */ + 0x30A1, 0x30A2, 0x30A3, 0x30A4, 0x30A5, 0x30A6, 0x30A7, 0x30A8, + 0x30A9, 0x30AA, 0x30AB, 0x30AC, 0x30AD, 0x30AE, 0x30AF, 0x30B0, + 0x30B1, 0x30B2, 0x30B3, 0x30B4, 0x30B5, 0x30B6, 0x30B7, 0x30B8, + 0x30B9, 0x30BA, 0x30BB, 0x30BC, 0x30BD, 0x30BE, 0x30BF, 0x30C0, + 0x30C1, 0x30C2, 0x30C3, 0x30C4, 0x30C5, 0x30C6, 0x30C7, 0x30C8, + 0x30C9, 0x30CA, 0x30CB, 0x30CC, 0x30CD, 0x30CE, 0x30CF, 0x30D0, + 0x30D1, 0x30D2, 0x30D3, 0x30D4, 0x30D5, 0x30D6, 0x30D7, 0x30D8, + 0x30D9, 0x30DA, 0x30DB, 0x30DC, 0x30DD, 0x30DE, 0x30DF, 0x30E0, + 0x30E1, 0x30E2, 0x30E3, 0x30E4, 0x30E5, 0x30E6, 0x30E7, 0x30E8, + 0x30E9, 0x30EA, 0x30EB, 0x30EC, 0x30ED, 0x30EE, 0x30EF, 0x30F0, + 0x30F1, 0x30F2, 0x30F3, 0x30F4, 0x30F5, 0x30F6, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 06 */ + 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, + 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0, + 0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, + 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0, + 0x03C1, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 07 */ + 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0401, 0x0416, + 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, + 0x041F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, + 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, + 0x042F, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0451, 0x0436, + 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, + 0x043F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, + 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, + 0x044F, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 08 */ + 0x2500, 0x2502, 0x250C, 0x2510, 0x2518, 0x2514, 0x251C, 0x252C, + 0x2524, 0x2534, 0x253C, 0x2501, 0x2503, 0x250F, 0x2513, 0x251B, + 0x2517, 0x2523, 0x2533, 0x252B, 0x253B, 0x254B, 0x2520, 0x252F, + 0x2528, 0x2537, 0x253F, 0x251D, 0x2530, 0x2525, 0x2538, 0x2542, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 09 */ + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 10 */ + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 11 */ + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 12 */ + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 13 */ + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 14 */ + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 15 */ + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 16 */ + 0x4E9C, 0x5516, 0x5A03, 0x963F, 0x54C0, 0x611B, 0x6328, 0x59F6, + 0x9022, 0x8475, 0x831C, 0x7A50, 0x60AA, 0x63E1, 0x6E25, 0x65ED, + 0x8466, 0x82A6, 0x9BF5, 0x6893, 0x5727, 0x65A1, 0x6271, 0x5B9B, + 0x59D0, 0x867B, 0x98F4, 0x7D62, 0x7DBE, 0x9B8E, 0x6216, 0x7C9F, + 0x88B7, 0x5B89, 0x5EB5, 0x6309, 0x6697, 0x6848, 0x95C7, 0x978D, + 0x674F, 0x4EE5, 0x4F0A, 0x4F4D, 0x4F9D, 0x5049, 0x56F2, 0x5937, + 0x59D4, 0x5A01, 0x5C09, 0x60DF, 0x610F, 0x6170, 0x6613, 0x6905, + 0x70BA, 0x754F, 0x7570, 0x79FB, 0x7DAD, 0x7DEF, 0x80C3, 0x840E, + 0x8863, 0x8B02, 0x9055, 0x907A, 0x533B, 0x4E95, 0x4EA5, 0x57DF, + 0x80B2, 0x90C1, 0x78EF, 0x4E00, 0x58F1, 0x6EA2, 0x9038, 0x7A32, + 0x8328, 0x828B, 0x9C2F, 0x5141, 0x5370, 0x54BD, 0x54E1, 0x56E0, + 0x59FB, 0x5F15, 0x98F2, 0x6DEB, 0x80E4, 0x852D + }, + { /* category 17 */ + 0x9662, 0x9670, 0x96A0, 0x97FB, 0x540B, 0x53F3, 0x5B87, 0x70CF, + 0x7FBD, 0x8FC2, 0x96E8, 0x536F, 0x9D5C, 0x7ABA, 0x4E11, 0x7893, + 0x81FC, 0x6E26, 0x5618, 0x5504, 0x6B1D, 0x851A, 0x9C3B, 0x59E5, + 0x53A9, 0x6D66, 0x74DC, 0x958F, 0x5642, 0x4E91, 0x904B, 0x96F2, + 0x834F, 0x990C, 0x53E1, 0x55B6, 0x5B30, 0x5F71, 0x6620, 0x66F3, + 0x6804, 0x6C38, 0x6CF3, 0x6D29, 0x745B, 0x76C8, 0x7A4E, 0x9834, + 0x82F1, 0x885B, 0x8A60, 0x92ED, 0x6DB2, 0x75AB, 0x76CA, 0x99C5, + 0x60A6, 0x8B01, 0x8D8A, 0x95B2, 0x698E, 0x53AD, 0x5186, 0x5712, + 0x5830, 0x5944, 0x5BB4, 0x5EF6, 0x6028, 0x63A9, 0x63F4, 0x6CBF, + 0x6F14, 0x708E, 0x7114, 0x7159, 0x71D5, 0x733F, 0x7E01, 0x8276, + 0x82D1, 0x8597, 0x9060, 0x925B, 0x9D1B, 0x5869, 0x65BC, 0x6C5A, + 0x7525, 0x51F9, 0x592E, 0x5965, 0x5F80, 0x5FDC + }, + { /* category 18 */ + 0x62BC, 0x65FA, 0x6A2A, 0x6B27, 0x6BB4, 0x738B, 0x7FC1, 0x8956, + 0x9D2C, 0x9D0E, 0x9EC4, 0x5CA1, 0x6C96, 0x837B, 0x5104, 0x5C4B, + 0x61B6, 0x81C6, 0x6876, 0x7261, 0x4E59, 0x4FFA, 0x5378, 0x6069, + 0x6E29, 0x7A4F, 0x97F3, 0x4E0B, 0x5316, 0x4EEE, 0x4F55, 0x4F3D, + 0x4FA1, 0x4F73, 0x52A0, 0x53EF, 0x5609, 0x590F, 0x5AC1, 0x5BB6, + 0x5BE1, 0x79D1, 0x6687, 0x679C, 0x67B6, 0x6B4C, 0x6CB3, 0x706B, + 0x73C2, 0x798D, 0x79BE, 0x7A3C, 0x7B87, 0x82B1, 0x82DB, 0x8304, + 0x8377, 0x83EF, 0x83D3, 0x8766, 0x8AB2, 0x5629, 0x8CA8, 0x8FE6, + 0x904E, 0x971E, 0x868A, 0x4FC4, 0x5CE8, 0x6211, 0x7259, 0x753B, + 0x81E5, 0x82BD, 0x86FE, 0x8CC0, 0x96C5, 0x9913, 0x99D5, 0x4ECB, + 0x4F1A, 0x89E3, 0x56DE, 0x584A, 0x58CA, 0x5EFB, 0x5FEB, 0x602A, + 0x6094, 0x6062, 0x61D0, 0x6212, 0x62D0, 0x6539 + }, + { /* category 19 */ + 0x9B41, 0x6666, 0x68B0, 0x6D77, 0x7070, 0x754C, 0x7686, 0x7D75, + 0x82A5, 0x87F9, 0x958B, 0x968E, 0x8C9D, 0x51F1, 0x52BE, 0x5916, + 0x54B3, 0x5BB3, 0x5D16, 0x6168, 0x6982, 0x6DAF, 0x788D, 0x84CB, + 0x8857, 0x8A72, 0x93A7, 0x9AB8, 0x6D6C, 0x99A8, 0x86D9, 0x57A3, + 0x67FF, 0x86CE, 0x920E, 0x5283, 0x5687, 0x5404, 0x5ED3, 0x62E1, + 0x64B9, 0x683C, 0x6838, 0x6BBB, 0x7372, 0x78BA, 0x7A6B, 0x899A, + 0x89D2, 0x8D6B, 0x8F03, 0x90ED, 0x95A3, 0x9694, 0x9769, 0x5B66, + 0x5CB3, 0x697D, 0x984D, 0x984E, 0x639B, 0x7B20, 0x6A2B, 0x6A7F, + 0x68B6, 0x9C0D, 0x6F5F, 0x5272, 0x559D, 0x6070, 0x62EC, 0x6D3B, + 0x6E07, 0x6ED1, 0x845B, 0x8910, 0x8F44, 0x4E14, 0x9C39, 0x53F6, + 0x691B, 0x6A3A, 0x9784, 0x682A, 0x515C, 0x7AC3, 0x84B2, 0x91DC, + 0x938C, 0x565B, 0x9D28, 0x6822, 0x8305, 0x8431 + }, + { /* category 20 */ + 0x7CA5, 0x5208, 0x82C5, 0x74E6, 0x4E7E, 0x4F83, 0x51A0, 0x5BD2, + 0x520A, 0x52D8, 0x52E7, 0x5DFB, 0x559A, 0x582A, 0x59E6, 0x5B8C, + 0x5B98, 0x5BDB, 0x5E72, 0x5E79, 0x60A3, 0x611F, 0x6163, 0x61BE, + 0x63DB, 0x6562, 0x67D1, 0x6853, 0x68FA, 0x6B3E, 0x6B53, 0x6C57, + 0x6F22, 0x6F97, 0x6F45, 0x74B0, 0x7518, 0x76E3, 0x770B, 0x7AFF, + 0x7BA1, 0x7C21, 0x7DE9, 0x7F36, 0x7FF0, 0x809D, 0x8266, 0x839E, + 0x89B3, 0x8ACC, 0x8CAB, 0x9084, 0x9451, 0x9593, 0x9591, 0x95A2, + 0x9665, 0x97D3, 0x9928, 0x8218, 0x4E38, 0x542B, 0x5CB8, 0x5DCC, + 0x73A9, 0x764C, 0x773C, 0x5CA9, 0x7FEB, 0x8D0B, 0x96C1, 0x9811, + 0x9854, 0x9858, 0x4F01, 0x4F0E, 0x5371, 0x559C, 0x5668, 0x57FA, + 0x5947, 0x5B09, 0x5BC4, 0x5C90, 0x5E0C, 0x5E7E, 0x5FCC, 0x63EE, + 0x673A, 0x65D7, 0x65E2, 0x671F, 0x68CB, 0x68C4 + }, + { /* category 21 */ + 0x6A5F, 0x5E30, 0x6BC5, 0x6C17, 0x6C7D, 0x757F, 0x7948, 0x5B63, + 0x7A00, 0x7D00, 0x5FBD, 0x898F, 0x8A18, 0x8CB4, 0x8D77, 0x8ECC, + 0x8F1D, 0x98E2, 0x9A0E, 0x9B3C, 0x4E80, 0x507D, 0x5100, 0x5993, + 0x5B9C, 0x622F, 0x6280, 0x64EC, 0x6B3A, 0x72A0, 0x7591, 0x7947, + 0x7FA9, 0x87FB, 0x8ABC, 0x8B70, 0x63AC, 0x83CA, 0x97A0, 0x5409, + 0x5403, 0x55AB, 0x6854, 0x6A58, 0x8A70, 0x7827, 0x6775, 0x9ECD, + 0x5374, 0x5BA2, 0x811A, 0x8650, 0x9006, 0x4E18, 0x4E45, 0x4EC7, + 0x4F11, 0x53CA, 0x5438, 0x5BAE, 0x5F13, 0x6025, 0x6551, 0x673D, + 0x6C42, 0x6C72, 0x6CE3, 0x7078, 0x7403, 0x7A76, 0x7AAE, 0x7B08, + 0x7D1A, 0x7CFE, 0x7D66, 0x65E7, 0x725B, 0x53BB, 0x5C45, 0x5DE8, + 0x62D2, 0x62E0, 0x6319, 0x6E20, 0x865A, 0x8A31, 0x8DDD, 0x92F8, + 0x6F01, 0x79A6, 0x9B5A, 0x4EA8, 0x4EAB, 0x4EAC + }, + { /* category 22 */ + 0x4F9B, 0x4FA0, 0x50D1, 0x5147, 0x7AF6, 0x5171, 0x51F6, 0x5354, + 0x5321, 0x537F, 0x53EB, 0x55AC, 0x5883, 0x5CE1, 0x5F37, 0x5F4A, + 0x602F, 0x6050, 0x606D, 0x631F, 0x6559, 0x6A4B, 0x6CC1, 0x72C2, + 0x72ED, 0x77EF, 0x80F8, 0x8105, 0x8208, 0x854E, 0x90F7, 0x93E1, + 0x97FF, 0x9957, 0x9A5A, 0x4EF0, 0x51DD, 0x5C2D, 0x6681, 0x696D, + 0x5C40, 0x66F2, 0x6975, 0x7389, 0x6850, 0x7C81, 0x50C5, 0x52E4, + 0x5747, 0x5DFE, 0x9326, 0x65A4, 0x6B23, 0x6B3D, 0x7434, 0x7981, + 0x79BD, 0x7B4B, 0x7DCA, 0x82B9, 0x83CC, 0x887F, 0x895F, 0x8B39, + 0x8FD1, 0x91D1, 0x541F, 0x9280, 0x4E5D, 0x5036, 0x53E5, 0x533A, + 0x72D7, 0x7396, 0x77E9, 0x82E6, 0x8EAF, 0x99C6, 0x99C8, 0x99D2, + 0x5177, 0x611A, 0x865E, 0x55B0, 0x7A7A, 0x5076, 0x5BD3, 0x9047, + 0x9685, 0x4E32, 0x6ADB, 0x91E7, 0x5C51, 0x5C48 + }, + { /* category 23 */ + 0x6398, 0x7A9F, 0x6C93, 0x9774, 0x8F61, 0x7AAA, 0x718A, 0x9688, + 0x7C82, 0x6817, 0x7E70, 0x6851, 0x936C, 0x52F2, 0x541B, 0x85AB, + 0x8A13, 0x7FA4, 0x8ECD, 0x90E1, 0x5366, 0x8888, 0x7941, 0x4FC2, + 0x50BE, 0x5211, 0x5144, 0x5553, 0x572D, 0x73EA, 0x578B, 0x5951, + 0x5F62, 0x5F84, 0x6075, 0x6176, 0x6167, 0x61A9, 0x63B2, 0x643A, + 0x656C, 0x666F, 0x6842, 0x6E13, 0x7566, 0x7A3D, 0x7CFB, 0x7D4C, + 0x7D99, 0x7E4B, 0x7F6B, 0x830E, 0x834A, 0x86CD, 0x8A08, 0x8A63, + 0x8B66, 0x8EFD, 0x981A, 0x9D8F, 0x82B8, 0x8FCE, 0x9BE8, 0x5287, + 0x621F, 0x6483, 0x6FC0, 0x9699, 0x6841, 0x5091, 0x6B20, 0x6C7A, + 0x6F54, 0x7A74, 0x7D50, 0x8840, 0x8A23, 0x6708, 0x4EF6, 0x5039, + 0x5026, 0x5065, 0x517C, 0x5238, 0x5263, 0x55A7, 0x570F, 0x5805, + 0x5ACC, 0x5EFA, 0x61B2, 0x61F8, 0x62F3, 0x6372 + }, + { /* category 24 */ + 0x691C, 0x6A29, 0x727D, 0x72AC, 0x732E, 0x7814, 0x786F, 0x7D79, + 0x770C, 0x80A9, 0x898B, 0x8B19, 0x8CE2, 0x8ED2, 0x9063, 0x9375, + 0x967A, 0x9855, 0x9A13, 0x9E78, 0x5143, 0x539F, 0x53B3, 0x5E7B, + 0x5F26, 0x6E1B, 0x6E90, 0x7384, 0x73FE, 0x7D43, 0x8237, 0x8A00, + 0x8AFA, 0x9650, 0x4E4E, 0x500B, 0x53E4, 0x547C, 0x56FA, 0x59D1, + 0x5B64, 0x5DF1, 0x5EAB, 0x5F27, 0x6238, 0x6545, 0x67AF, 0x6E56, + 0x72D0, 0x7CCA, 0x88B4, 0x80A1, 0x80E1, 0x83F0, 0x864E, 0x8A87, + 0x8DE8, 0x9237, 0x96C7, 0x9867, 0x9F13, 0x4E94, 0x4E92, 0x4F0D, + 0x5348, 0x5449, 0x543E, 0x5A2F, 0x5F8C, 0x5FA1, 0x609F, 0x68A7, + 0x6A8E, 0x745A, 0x7881, 0x8A9E, 0x8AA4, 0x8B77, 0x9190, 0x4E5E, + 0x9BC9, 0x4EA4, 0x4F7C, 0x4FAF, 0x5019, 0x5016, 0x5149, 0x516C, + 0x529F, 0x52B9, 0x52FE, 0x539A, 0x53E3, 0x5411 + }, + { /* category 25 */ + 0x540E, 0x5589, 0x5751, 0x57A2, 0x597D, 0x5B54, 0x5B5D, 0x5B8F, + 0x5DE5, 0x5DE7, 0x5DF7, 0x5E78, 0x5E83, 0x5E9A, 0x5EB7, 0x5F18, + 0x6052, 0x614C, 0x6297, 0x62D8, 0x63A7, 0x653B, 0x6602, 0x6643, + 0x66F4, 0x676D, 0x6821, 0x6897, 0x69CB, 0x6C5F, 0x6D2A, 0x6D69, + 0x6E2F, 0x6E9D, 0x7532, 0x7687, 0x786C, 0x7A3F, 0x7CE0, 0x7D05, + 0x7D18, 0x7D5E, 0x7DB1, 0x8015, 0x8003, 0x80AF, 0x80B1, 0x8154, + 0x818F, 0x822A, 0x8352, 0x884C, 0x8861, 0x8B1B, 0x8CA2, 0x8CFC, + 0x90CA, 0x9175, 0x9271, 0x783F, 0x92FC, 0x95A4, 0x964D, 0x9805, + 0x9999, 0x9AD8, 0x9D3B, 0x525B, 0x52AB, 0x53F7, 0x5408, 0x58D5, + 0x62F7, 0x6FE0, 0x8C6A, 0x8F5F, 0x9EB9, 0x514B, 0x523B, 0x544A, + 0x56FD, 0x7A40, 0x9177, 0x9D60, 0x9ED2, 0x7344, 0x6F09, 0x8170, + 0x7511, 0x5FFD, 0x60DA, 0x9AA8, 0x72DB, 0x8FBC + }, + { /* category 26 */ + 0x6B64, 0x9803, 0x4ECA, 0x56F0, 0x5764, 0x58BE, 0x5A5A, 0x6068, + 0x61C7, 0x660F, 0x6606, 0x6839, 0x68B1, 0x6DF7, 0x75D5, 0x7D3A, + 0x826E, 0x9B42, 0x4E9B, 0x4F50, 0x53C9, 0x5506, 0x5D6F, 0x5DE6, + 0x5DEE, 0x67FB, 0x6C99, 0x7473, 0x7802, 0x8A50, 0x9396, 0x88DF, + 0x5750, 0x5EA7, 0x632B, 0x50B5, 0x50AC, 0x518D, 0x6700, 0x54C9, + 0x585E, 0x59BB, 0x5BB0, 0x5F69, 0x624D, 0x63A1, 0x683D, 0x6B73, + 0x6E08, 0x707D, 0x91C7, 0x7280, 0x7815, 0x7826, 0x796D, 0x658E, + 0x7D30, 0x83DC, 0x88C1, 0x8F09, 0x969B, 0x5264, 0x5728, 0x6750, + 0x7F6A, 0x8CA1, 0x51B4, 0x5742, 0x962A, 0x583A, 0x698A, 0x80B4, + 0x54B2, 0x5D0E, 0x57FC, 0x7895, 0x9DFA, 0x4F5C, 0x524A, 0x548B, + 0x643E, 0x6628, 0x6714, 0x67F5, 0x7A84, 0x7B56, 0x7D22, 0x932F, + 0x685C, 0x9BAD, 0x7B39, 0x5319, 0x518A, 0x5237 + }, + { /* category 27 */ + 0x5BDF, 0x62F6, 0x64AE, 0x64E6, 0x672D, 0x6BBA, 0x85A9, 0x96D1, + 0x7690, 0x9BD6, 0x634C, 0x9306, 0x9BAB, 0x76BF, 0x6652, 0x4E09, + 0x5098, 0x53C2, 0x5C71, 0x60E8, 0x6492, 0x6563, 0x685F, 0x71E6, + 0x73CA, 0x7523, 0x7B97, 0x7E82, 0x8695, 0x8B83, 0x8CDB, 0x9178, + 0x9910, 0x65AC, 0x66AB, 0x6B8B, 0x4ED5, 0x4ED4, 0x4F3A, 0x4F7F, + 0x523A, 0x53F8, 0x53F2, 0x55E3, 0x56DB, 0x58EB, 0x59CB, 0x59C9, + 0x59FF, 0x5B50, 0x5C4D, 0x5E02, 0x5E2B, 0x5FD7, 0x601D, 0x6307, + 0x652F, 0x5B5C, 0x65AF, 0x65BD, 0x65E8, 0x679D, 0x6B62, 0x6B7B, + 0x6C0F, 0x7345, 0x7949, 0x79C1, 0x7CF8, 0x7D19, 0x7D2B, 0x80A2, + 0x8102, 0x81F3, 0x8996, 0x8A5E, 0x8A69, 0x8A66, 0x8A8C, 0x8AEE, + 0x8CC7, 0x8CDC, 0x96CC, 0x98FC, 0x6B6F, 0x4E8B, 0x4F3C, 0x4F8D, + 0x5150, 0x5B57, 0x5BFA, 0x6148, 0x6301, 0x6642 + }, + { /* category 28 */ + 0x6B21, 0x6ECB, 0x6CBB, 0x723E, 0x74BD, 0x75D4, 0x78C1, 0x793A, + 0x800C, 0x8033, 0x81EA, 0x8494, 0x8F9E, 0x6C50, 0x9E7F, 0x5F0F, + 0x8B58, 0x9D2B, 0x7AFA, 0x8EF8, 0x5B8D, 0x96EB, 0x4E03, 0x53F1, + 0x57F7, 0x5931, 0x5AC9, 0x5BA4, 0x6089, 0x6E7F, 0x6F06, 0x75BE, + 0x8CEA, 0x5B9F, 0x8500, 0x7BE0, 0x5072, 0x67F4, 0x829D, 0x5C61, + 0x854A, 0x7E1E, 0x820E, 0x5199, 0x5C04, 0x6368, 0x8D66, 0x659C, + 0x716E, 0x793E, 0x7D17, 0x8005, 0x8B1D, 0x8ECA, 0x906E, 0x86C7, + 0x90AA, 0x501F, 0x52FA, 0x5C3A, 0x6753, 0x707C, 0x7235, 0x914C, + 0x91C8, 0x932B, 0x82E5, 0x5BC2, 0x5F31, 0x60F9, 0x4E3B, 0x53D6, + 0x5B88, 0x624B, 0x6731, 0x6B8A, 0x72E9, 0x73E0, 0x7A2E, 0x816B, + 0x8DA3, 0x9152, 0x9996, 0x5112, 0x53D7, 0x546A, 0x5BFF, 0x6388, + 0x6A39, 0x7DAC, 0x9700, 0x56DA, 0x53CE, 0x5468 + }, + { /* category 29 */ + 0x5B97, 0x5C31, 0x5DDE, 0x4FEE, 0x6101, 0x62FE, 0x6D32, 0x79C0, + 0x79CB, 0x7D42, 0x7E4D, 0x7FD2, 0x81ED, 0x821F, 0x8490, 0x8846, + 0x8972, 0x8B90, 0x8E74, 0x8F2F, 0x9031, 0x914B, 0x916C, 0x96C6, + 0x919C, 0x4EC0, 0x4F4F, 0x5145, 0x5341, 0x5F93, 0x620E, 0x67D4, + 0x6C41, 0x6E0B, 0x7363, 0x7E26, 0x91CD, 0x9283, 0x53D4, 0x5919, + 0x5BBF, 0x6DD1, 0x795D, 0x7E2E, 0x7C9B, 0x587E, 0x719F, 0x51FA, + 0x8853, 0x8FF0, 0x4FCA, 0x5CFB, 0x6625, 0x77AC, 0x7AE3, 0x821C, + 0x99FF, 0x51C6, 0x5FAA, 0x65EC, 0x696F, 0x6B89, 0x6DF3, 0x6E96, + 0x6F64, 0x76FE, 0x7D14, 0x5DE1, 0x9075, 0x9187, 0x9806, 0x51E6, + 0x521D, 0x6240, 0x6691, 0x66D9, 0x6E1A, 0x5EB6, 0x7DD2, 0x7F72, + 0x66F8, 0x85AF, 0x85F7, 0x8AF8, 0x52A9, 0x53D9, 0x5973, 0x5E8F, + 0x5F90, 0x6055, 0x92E4, 0x9664, 0x50B7, 0x511F + }, + { /* category 30 */ + 0x52DD, 0x5320, 0x5347, 0x53EC, 0x54E8, 0x5546, 0x5531, 0x5617, + 0x5968, 0x59BE, 0x5A3C, 0x5BB5, 0x5C06, 0x5C0F, 0x5C11, 0x5C1A, + 0x5E84, 0x5E8A, 0x5EE0, 0x5F70, 0x627F, 0x6284, 0x62DB, 0x638C, + 0x6377, 0x6607, 0x660C, 0x662D, 0x6676, 0x677E, 0x68A2, 0x6A1F, + 0x6A35, 0x6CBC, 0x6D88, 0x6E09, 0x6E58, 0x713C, 0x7126, 0x7167, + 0x75C7, 0x7701, 0x785D, 0x7901, 0x7965, 0x79F0, 0x7AE0, 0x7B11, + 0x7CA7, 0x7D39, 0x8096, 0x83D6, 0x848B, 0x8549, 0x885D, 0x88F3, + 0x8A1F, 0x8A3C, 0x8A54, 0x8A73, 0x8C61, 0x8CDE, 0x91A4, 0x9266, + 0x937E, 0x9418, 0x969C, 0x9798, 0x4E0A, 0x4E08, 0x4E1E, 0x4E57, + 0x5197, 0x5270, 0x57CE, 0x5834, 0x58CC, 0x5B22, 0x5E38, 0x60C5, + 0x64FE, 0x6761, 0x6756, 0x6D44, 0x72B6, 0x7573, 0x7A63, 0x84B8, + 0x8B72, 0x91B8, 0x9320, 0x5631, 0x57F4, 0x98FE + }, + { /* category 31 */ + 0x62ED, 0x690D, 0x6B96, 0x71ED, 0x7E54, 0x8077, 0x8272, 0x89E6, + 0x98DF, 0x8755, 0x8FB1, 0x5C3B, 0x4F38, 0x4FE1, 0x4FB5, 0x5507, + 0x5A20, 0x5BDD, 0x5BE9, 0x5FC3, 0x614E, 0x632F, 0x65B0, 0x664B, + 0x68EE, 0x699B, 0x6D78, 0x6DF1, 0x7533, 0x75B9, 0x771F, 0x795E, + 0x79E6, 0x7D33, 0x81E3, 0x82AF, 0x85AA, 0x89AA, 0x8A3A, 0x8EAB, + 0x8F9B, 0x9032, 0x91DD, 0x9707, 0x4EBA, 0x4EC1, 0x5203, 0x5875, + 0x58EC, 0x5C0B, 0x751A, 0x5C3D, 0x814E, 0x8A0A, 0x8FC5, 0x9663, + 0x976D, 0x7B25, 0x8ACF, 0x9808, 0x9162, 0x56F3, 0x53A8, 0x9017, + 0x5439, 0x5782, 0x5E25, 0x63A8, 0x6C34, 0x708A, 0x7761, 0x7C8B, + 0x7FE0, 0x8870, 0x9042, 0x9154, 0x9310, 0x9318, 0x968F, 0x745E, + 0x9AC4, 0x5D07, 0x5D69, 0x6570, 0x67A2, 0x8DA8, 0x96DB, 0x636E, + 0x6749, 0x6919, 0x83C5, 0x9817, 0x96C0, 0x88FE + }, + { /* category 32 */ + 0x6F84, 0x647A, 0x5BF8, 0x4E16, 0x702C, 0x755D, 0x662F, 0x51C4, + 0x5236, 0x52E2, 0x59D3, 0x5F81, 0x6027, 0x6210, 0x653F, 0x6574, + 0x661F, 0x6674, 0x68F2, 0x6816, 0x6B63, 0x6E05, 0x7272, 0x751F, + 0x76DB, 0x7CBE, 0x8056, 0x58F0, 0x88FD, 0x897F, 0x8AA0, 0x8A93, + 0x8ACB, 0x901D, 0x9192, 0x9752, 0x9759, 0x6589, 0x7A0E, 0x8106, + 0x96BB, 0x5E2D, 0x60DC, 0x621A, 0x65A5, 0x6614, 0x6790, 0x77F3, + 0x7A4D, 0x7C4D, 0x7E3E, 0x810A, 0x8CAC, 0x8D64, 0x8DE1, 0x8E5F, + 0x78A9, 0x5207, 0x62D9, 0x63A5, 0x6442, 0x6298, 0x8A2D, 0x7A83, + 0x7BC0, 0x8AAC, 0x96EA, 0x7D76, 0x820C, 0x8749, 0x4ED9, 0x5148, + 0x5343, 0x5360, 0x5BA3, 0x5C02, 0x5C16, 0x5DDD, 0x6226, 0x6247, + 0x64B0, 0x6813, 0x6834, 0x6CC9, 0x6D45, 0x6D17, 0x67D3, 0x6F5C, + 0x714E, 0x717D, 0x65CB, 0x7A7F, 0x7BAD, 0x7DDA + }, + { /* category 33 */ + 0x7E4A, 0x7FA8, 0x817A, 0x821B, 0x8239, 0x85A6, 0x8A6E, 0x8CCE, + 0x8DF5, 0x9078, 0x9077, 0x92AD, 0x9291, 0x9583, 0x9BAE, 0x524D, + 0x5584, 0x6F38, 0x7136, 0x5168, 0x7985, 0x7E55, 0x81B3, 0x7CCE, + 0x564C, 0x5851, 0x5CA8, 0x63AA, 0x66FE, 0x66FD, 0x695A, 0x72D9, + 0x758F, 0x758E, 0x790E, 0x7956, 0x79DF, 0x7C97, 0x7D20, 0x7D44, + 0x8607, 0x8A34, 0x963B, 0x9061, 0x9F20, 0x50E7, 0x5275, 0x53CC, + 0x53E2, 0x5009, 0x55AA, 0x58EE, 0x594F, 0x723D, 0x5B8B, 0x5C64, + 0x531D, 0x60E3, 0x60F3, 0x635C, 0x6383, 0x633F, 0x63BB, 0x64CD, + 0x65E9, 0x66F9, 0x5DE3, 0x69CD, 0x69FD, 0x6F15, 0x71E5, 0x4E89, + 0x75E9, 0x76F8, 0x7A93, 0x7CDF, 0x7DCF, 0x7D9C, 0x8061, 0x8349, + 0x8358, 0x846C, 0x84BC, 0x85FB, 0x88C5, 0x8D70, 0x9001, 0x906D, + 0x9397, 0x971C, 0x9A12, 0x50CF, 0x5897, 0x618E + }, + { /* category 34 */ + 0x81D3, 0x8535, 0x8D08, 0x9020, 0x4FC3, 0x5074, 0x5247, 0x5373, + 0x606F, 0x6349, 0x675F, 0x6E2C, 0x8DB3, 0x901F, 0x4FD7, 0x5C5E, + 0x8CCA, 0x65CF, 0x7D9A, 0x5352, 0x8896, 0x5176, 0x63C3, 0x5B58, + 0x5B6B, 0x5C0A, 0x640D, 0x6751, 0x905C, 0x4ED6, 0x591A, 0x592A, + 0x6C70, 0x8A51, 0x553E, 0x5815, 0x59A5, 0x60F0, 0x6253, 0x67C1, + 0x8235, 0x6955, 0x9640, 0x99C4, 0x9A28, 0x4F53, 0x5806, 0x5BFE, + 0x8010, 0x5CB1, 0x5E2F, 0x5F85, 0x6020, 0x614B, 0x6234, 0x66FF, + 0x6CF0, 0x6EDE, 0x80CE, 0x817F, 0x82D4, 0x888B, 0x8CB8, 0x9000, + 0x902E, 0x968A, 0x9EDB, 0x9BDB, 0x4EE3, 0x53F0, 0x5927, 0x7B2C, + 0x918D, 0x984C, 0x9DF9, 0x6EDD, 0x7027, 0x5353, 0x5544, 0x5B85, + 0x6258, 0x629E, 0x62D3, 0x6CA2, 0x6FEF, 0x7422, 0x8A17, 0x9438, + 0x6FC1, 0x8AFE, 0x8338, 0x51E7, 0x86F8, 0x53EA + }, + { /* category 35 */ + 0x53E9, 0x4F46, 0x9054, 0x8FB0, 0x596A, 0x8131, 0x5DFD, 0x7AEA, + 0x8FBF, 0x68DA, 0x8C37, 0x72F8, 0x9C48, 0x6A3D, 0x8AB0, 0x4E39, + 0x5358, 0x5606, 0x5766, 0x62C5, 0x63A2, 0x65E6, 0x6B4E, 0x6DE1, + 0x6E5B, 0x70AD, 0x77ED, 0x7AEF, 0x7BAA, 0x7DBB, 0x803D, 0x80C6, + 0x86CB, 0x8A95, 0x935B, 0x56E3, 0x58C7, 0x5F3E, 0x65AD, 0x6696, + 0x6A80, 0x6BB5, 0x7537, 0x8AC7, 0x5024, 0x77E5, 0x5730, 0x5F1B, + 0x6065, 0x667A, 0x6C60, 0x75F4, 0x7A1A, 0x7F6E, 0x81F4, 0x8718, + 0x9045, 0x99B3, 0x7BC9, 0x755C, 0x7AF9, 0x7B51, 0x84C4, 0x9010, + 0x79E9, 0x7A92, 0x8336, 0x5AE1, 0x7740, 0x4E2D, 0x4EF2, 0x5B99, + 0x5FE0, 0x62BD, 0x663C, 0x67F1, 0x6CE8, 0x866B, 0x8877, 0x8A3B, + 0x914E, 0x92F3, 0x99D0, 0x6A17, 0x7026, 0x732A, 0x82E7, 0x8457, + 0x8CAF, 0x4E01, 0x5146, 0x51CB, 0x558B, 0x5BF5 + }, + { /* category 36 */ + 0x5E16, 0x5E33, 0x5E81, 0x5F14, 0x5F35, 0x5F6B, 0x5FB4, 0x61F2, + 0x6311, 0x66A2, 0x671D, 0x6F6E, 0x7252, 0x753A, 0x773A, 0x8074, + 0x8139, 0x8178, 0x8776, 0x8ABF, 0x8ADC, 0x8D85, 0x8DF3, 0x929A, + 0x9577, 0x9802, 0x9CE5, 0x52C5, 0x6357, 0x76F4, 0x6715, 0x6C88, + 0x73CD, 0x8CC3, 0x93AE, 0x9673, 0x6D25, 0x589C, 0x690E, 0x69CC, + 0x8FFD, 0x939A, 0x75DB, 0x901A, 0x585A, 0x6802, 0x63B4, 0x69FB, + 0x4F43, 0x6F2C, 0x67D8, 0x8FBB, 0x8526, 0x7DB4, 0x9354, 0x693F, + 0x6F70, 0x576A, 0x58F7, 0x5B2C, 0x7D2C, 0x722A, 0x540A, 0x91E3, + 0x9DB4, 0x4EAD, 0x4F4E, 0x505C, 0x5075, 0x5243, 0x8C9E, 0x5448, + 0x5824, 0x5B9A, 0x5E1D, 0x5E95, 0x5EAD, 0x5EF7, 0x5F1F, 0x608C, + 0x62B5, 0x633A, 0x63D0, 0x68AF, 0x6C40, 0x7887, 0x798E, 0x7A0B, + 0x7DE0, 0x8247, 0x8A02, 0x8AE6, 0x8E44, 0x9013 + }, + { /* category 37 */ + 0x90B8, 0x912D, 0x91D8, 0x9F0E, 0x6CE5, 0x6458, 0x64E2, 0x6575, + 0x6EF4, 0x7684, 0x7B1B, 0x9069, 0x93D1, 0x6EBA, 0x54F2, 0x5FB9, + 0x64A4, 0x8F4D, 0x8FED, 0x9244, 0x5178, 0x586B, 0x5929, 0x5C55, + 0x5E97, 0x6DFB, 0x7E8F, 0x751C, 0x8CBC, 0x8EE2, 0x985B, 0x70B9, + 0x4F1D, 0x6BBF, 0x6FB1, 0x7530, 0x96FB, 0x514E, 0x5410, 0x5835, + 0x5857, 0x59AC, 0x5C60, 0x5F92, 0x6597, 0x675C, 0x6E21, 0x767B, + 0x83DF, 0x8CED, 0x9014, 0x90FD, 0x934D, 0x7825, 0x783A, 0x52AA, + 0x5EA6, 0x571F, 0x5974, 0x6012, 0x5012, 0x515A, 0x51AC, 0x51CD, + 0x5200, 0x5510, 0x5854, 0x5858, 0x5957, 0x5B95, 0x5CF6, 0x5D8B, + 0x60BC, 0x6295, 0x642D, 0x6771, 0x6843, 0x68BC, 0x68DF, 0x76D7, + 0x6DD8, 0x6E6F, 0x6D9B, 0x706F, 0x71C8, 0x5F53, 0x75D8, 0x7977, + 0x7B49, 0x7B54, 0x7B52, 0x7CD6, 0x7D71, 0x5230 + }, + { /* category 38 */ + 0x8463, 0x8569, 0x85E4, 0x8A0E, 0x8B04, 0x8C46, 0x8E0F, 0x9003, + 0x900F, 0x9419, 0x9676, 0x982D, 0x9A30, 0x95D8, 0x50CD, 0x52D5, + 0x540C, 0x5802, 0x5C0E, 0x61A7, 0x649E, 0x6D1E, 0x77B3, 0x7AE5, + 0x80F4, 0x8404, 0x9053, 0x9285, 0x5CE0, 0x9D07, 0x533F, 0x5F97, + 0x5FB3, 0x6D9C, 0x7279, 0x7763, 0x79BF, 0x7BE4, 0x6BD2, 0x72EC, + 0x8AAD, 0x6803, 0x6A61, 0x51F8, 0x7A81, 0x6934, 0x5C4A, 0x9CF6, + 0x82EB, 0x5BC5, 0x9149, 0x701E, 0x5678, 0x5C6F, 0x60C7, 0x6566, + 0x6C8C, 0x8C5A, 0x9041, 0x9813, 0x5451, 0x66C7, 0x920D, 0x5948, + 0x90A3, 0x5185, 0x4E4D, 0x51EA, 0x8599, 0x8B0E, 0x7058, 0x637A, + 0x934B, 0x6962, 0x99B4, 0x7E04, 0x7577, 0x5357, 0x6960, 0x8EDF, + 0x96E3, 0x6C5D, 0x4E8C, 0x5C3C, 0x5F10, 0x8FE9, 0x5302, 0x8CD1, + 0x8089, 0x8679, 0x5EFF, 0x65E5, 0x4E73, 0x5165 + }, + { /* category 39 */ + 0x5982, 0x5C3F, 0x97EE, 0x4EFB, 0x598A, 0x5FCD, 0x8A8D, 0x6FE1, + 0x79B0, 0x7962, 0x5BE7, 0x8471, 0x732B, 0x71B1, 0x5E74, 0x5FF5, + 0x637B, 0x649A, 0x71C3, 0x7C98, 0x4E43, 0x5EFC, 0x4E4B, 0x57DC, + 0x56A2, 0x60A9, 0x6FC3, 0x7D0D, 0x80FD, 0x8133, 0x81BF, 0x8FB2, + 0x8997, 0x86A4, 0x5DF4, 0x628A, 0x64AD, 0x8987, 0x6777, 0x6CE2, + 0x6D3E, 0x7436, 0x7834, 0x5A46, 0x7F75, 0x82AD, 0x99AC, 0x4FF3, + 0x5EC3, 0x62DD, 0x6392, 0x6557, 0x676F, 0x76C3, 0x724C, 0x80CC, + 0x80BA, 0x8F29, 0x914D, 0x500D, 0x57F9, 0x5A92, 0x6885, 0x6973, + 0x7164, 0x72FD, 0x8CB7, 0x58F2, 0x8CE0, 0x966A, 0x9019, 0x877F, + 0x79E4, 0x77E7, 0x8429, 0x4F2F, 0x5265, 0x535A, 0x62CD, 0x67CF, + 0x6CCA, 0x767D, 0x7B94, 0x7C95, 0x8236, 0x8584, 0x8FEB, 0x66DD, + 0x6F20, 0x7206, 0x7E1B, 0x83AB, 0x99C1, 0x9EA6 + }, + { /* category 40 */ + 0x51FD, 0x7BB1, 0x7872, 0x7BB8, 0x8087, 0x7B48, 0x6AE8, 0x5E61, + 0x808C, 0x7551, 0x7560, 0x516B, 0x9262, 0x6E8C, 0x767A, 0x9197, + 0x9AEA, 0x4F10, 0x7F70, 0x629C, 0x7B4F, 0x95A5, 0x9CE9, 0x567A, + 0x5859, 0x86E4, 0x96BC, 0x4F34, 0x5224, 0x534A, 0x53CD, 0x53DB, + 0x5E06, 0x642C, 0x6591, 0x677F, 0x6C3E, 0x6C4E, 0x7248, 0x72AF, + 0x73ED, 0x7554, 0x7E41, 0x822C, 0x85E9, 0x8CA9, 0x7BC4, 0x91C6, + 0x7169, 0x9812, 0x98EF, 0x633D, 0x6669, 0x756A, 0x76E4, 0x78D0, + 0x8543, 0x86EE, 0x532A, 0x5351, 0x5426, 0x5983, 0x5E87, 0x5F7C, + 0x60B2, 0x6249, 0x6279, 0x62AB, 0x6590, 0x6BD4, 0x6CCC, 0x75B2, + 0x76AE, 0x7891, 0x79D8, 0x7DCB, 0x7F77, 0x80A5, 0x88AB, 0x8AB9, + 0x8CBB, 0x907F, 0x975E, 0x98DB, 0x6A0B, 0x7C38, 0x5099, 0x5C3E, + 0x5FAE, 0x6787, 0x6BD8, 0x7435, 0x7709, 0x7F8E + }, + { /* category 41 */ + 0x9F3B, 0x67CA, 0x7A17, 0x5339, 0x758B, 0x9AED, 0x5F66, 0x819D, + 0x83F1, 0x8098, 0x5F3C, 0x5FC5, 0x7562, 0x7B46, 0x903C, 0x6867, + 0x59EB, 0x5A9B, 0x7D10, 0x767E, 0x8B2C, 0x4FF5, 0x5F6A, 0x6A19, + 0x6C37, 0x6F02, 0x74E2, 0x7968, 0x8868, 0x8A55, 0x8C79, 0x5EDF, + 0x63CF, 0x75C5, 0x79D2, 0x82D7, 0x9328, 0x92F2, 0x849C, 0x86ED, + 0x9C2D, 0x54C1, 0x5F6C, 0x658C, 0x6D5C, 0x7015, 0x8CA7, 0x8CD3, + 0x983B, 0x654F, 0x74F6, 0x4E0D, 0x4ED8, 0x57E0, 0x592B, 0x5A66, + 0x5BCC, 0x51A8, 0x5E03, 0x5E9C, 0x6016, 0x6276, 0x6577, 0x65A7, + 0x666E, 0x6D6E, 0x7236, 0x7B26, 0x8150, 0x819A, 0x8299, 0x8B5C, + 0x8CA0, 0x8CE6, 0x8D74, 0x961C, 0x9644, 0x4FAE, 0x64AB, 0x6B66, + 0x821E, 0x8461, 0x856A, 0x90E8, 0x5C01, 0x6953, 0x98A8, 0x847A, + 0x8557, 0x4F0F, 0x526F, 0x5FA9, 0x5E45, 0x670D + }, + { /* category 42 */ + 0x798F, 0x8179, 0x8907, 0x8986, 0x6DF5, 0x5F17, 0x6255, 0x6CB8, + 0x4ECF, 0x7269, 0x9B92, 0x5206, 0x543B, 0x5674, 0x58B3, 0x61A4, + 0x626E, 0x711A, 0x596E, 0x7C89, 0x7CDE, 0x7D1B, 0x96F0, 0x6587, + 0x805E, 0x4E19, 0x4F75, 0x5175, 0x5840, 0x5E63, 0x5E73, 0x5F0A, + 0x67C4, 0x4E26, 0x853D, 0x9589, 0x965B, 0x7C73, 0x9801, 0x50FB, + 0x58C1, 0x7656, 0x78A7, 0x5225, 0x77A5, 0x8511, 0x7B86, 0x504F, + 0x5909, 0x7247, 0x7BC7, 0x7DE8, 0x8FBA, 0x8FD4, 0x904D, 0x4FBF, + 0x52C9, 0x5A29, 0x5F01, 0x97AD, 0x4FDD, 0x8217, 0x92EA, 0x5703, + 0x6355, 0x6B69, 0x752B, 0x88DC, 0x8F14, 0x7A42, 0x52DF, 0x5893, + 0x6155, 0x620A, 0x66AE, 0x6BCD, 0x7C3F, 0x83E9, 0x5023, 0x4FF8, + 0x5305, 0x5446, 0x5831, 0x5949, 0x5B9D, 0x5CF0, 0x5CEF, 0x5D29, + 0x5E96, 0x62B1, 0x6367, 0x653E, 0x65B9, 0x670B + }, + { /* category 43 */ + 0x6CD5, 0x6CE1, 0x70F9, 0x7832, 0x7E2B, 0x80DE, 0x82B3, 0x840C, + 0x84EC, 0x8702, 0x8912, 0x8A2A, 0x8C4A, 0x90A6, 0x92D2, 0x98FD, + 0x9CF3, 0x9D6C, 0x4E4F, 0x4EA1, 0x508D, 0x5256, 0x574A, 0x59A8, + 0x5E3D, 0x5FD8, 0x5FD9, 0x623F, 0x66B4, 0x671B, 0x67D0, 0x68D2, + 0x5192, 0x7D21, 0x80AA, 0x81A8, 0x8B00, 0x8C8C, 0x8CBF, 0x927E, + 0x9632, 0x5420, 0x982C, 0x5317, 0x50D5, 0x535C, 0x58A8, 0x64B2, + 0x6734, 0x7267, 0x7766, 0x7A46, 0x91E6, 0x52C3, 0x6CA1, 0x6B86, + 0x5800, 0x5E4C, 0x5954, 0x672C, 0x7FFB, 0x51E1, 0x76C6, 0x6469, + 0x78E8, 0x9B54, 0x9EBB, 0x57CB, 0x59B9, 0x6627, 0x679A, 0x6BCE, + 0x54E9, 0x69D9, 0x5E55, 0x819C, 0x6795, 0x9BAA, 0x67FE, 0x9C52, + 0x685D, 0x4EA6, 0x4FE3, 0x53C8, 0x62B9, 0x672B, 0x6CAB, 0x8FC4, + 0x4FAD, 0x7E6D, 0x9EBF, 0x4E07, 0x6162, 0x6E80 + }, + { /* category 44 */ + 0x6F2B, 0x8513, 0x5473, 0x672A, 0x9B45, 0x5DF3, 0x7B95, 0x5CAC, + 0x5BC6, 0x871C, 0x6E4A, 0x84D1, 0x7A14, 0x8108, 0x5999, 0x7C8D, + 0x6C11, 0x7720, 0x52D9, 0x5922, 0x7121, 0x725F, 0x77DB, 0x9727, + 0x9D61, 0x690B, 0x5A7F, 0x5A18, 0x51A5, 0x540D, 0x547D, 0x660E, + 0x76DF, 0x8FF7, 0x9298, 0x9CF4, 0x59EA, 0x725D, 0x6EC5, 0x514D, + 0x68C9, 0x7DBF, 0x7DEC, 0x9762, 0x9EBA, 0x6478, 0x6A21, 0x8302, + 0x5984, 0x5B5F, 0x6BDB, 0x731B, 0x76F2, 0x7DB2, 0x8017, 0x8499, + 0x5132, 0x6728, 0x9ED9, 0x76EE, 0x6762, 0x52FF, 0x9905, 0x5C24, + 0x623B, 0x7C7E, 0x8CB0, 0x554F, 0x60B6, 0x7D0B, 0x9580, 0x5301, + 0x4E5F, 0x51B6, 0x591C, 0x723A, 0x8036, 0x91CE, 0x5F25, 0x77E2, + 0x5384, 0x5F79, 0x7D04, 0x85AC, 0x8A33, 0x8E8D, 0x9756, 0x67F3, + 0x85AE, 0x9453, 0x6109, 0x6108, 0x6CB9, 0x7652 + }, + { /* category 45 */ + 0x8AED, 0x8F38, 0x552F, 0x4F51, 0x512A, 0x52C7, 0x53CB, 0x5BA5, + 0x5E7D, 0x60A0, 0x6182, 0x63D6, 0x6709, 0x67DA, 0x6E67, 0x6D8C, + 0x7336, 0x7337, 0x7531, 0x7950, 0x88D5, 0x8A98, 0x904A, 0x9091, + 0x90F5, 0x96C4, 0x878D, 0x5915, 0x4E88, 0x4F59, 0x4E0E, 0x8A89, + 0x8F3F, 0x9810, 0x50AD, 0x5E7C, 0x5996, 0x5BB9, 0x5EB8, 0x63DA, + 0x63FA, 0x64C1, 0x66DC, 0x694A, 0x69D8, 0x6D0B, 0x6EB6, 0x7194, + 0x7528, 0x7AAF, 0x7F8A, 0x8000, 0x8449, 0x84C9, 0x8981, 0x8B21, + 0x8E0A, 0x9065, 0x967D, 0x990A, 0x617E, 0x6291, 0x6B32, 0x6C83, + 0x6D74, 0x7FCC, 0x7FFC, 0x6DC0, 0x7F85, 0x87BA, 0x88F8, 0x6765, + 0x83B1, 0x983C, 0x96F7, 0x6D1B, 0x7D61, 0x843D, 0x916A, 0x4E71, + 0x5375, 0x5D50, 0x6B04, 0x6FEB, 0x85CD, 0x862D, 0x89A7, 0x5229, + 0x540F, 0x5C65, 0x674E, 0x68A8, 0x7406, 0x7483 + }, + { /* category 46 */ + 0x75E2, 0x88CF, 0x88E1, 0x91CC, 0x96E2, 0x9678, 0x5F8B, 0x7387, + 0x7ACB, 0x844E, 0x63A0, 0x7565, 0x5289, 0x6D41, 0x6E9C, 0x7409, + 0x7559, 0x786B, 0x7C92, 0x9686, 0x7ADC, 0x9F8D, 0x4FB6, 0x616E, + 0x65C5, 0x865C, 0x4E86, 0x4EAE, 0x50DA, 0x4E21, 0x51CC, 0x5BEE, + 0x6599, 0x6881, 0x6DBC, 0x731F, 0x7642, 0x77AD, 0x7A1C, 0x7CE7, + 0x826F, 0x8AD2, 0x907C, 0x91CF, 0x9675, 0x9818, 0x529B, 0x7DD1, + 0x502B, 0x5398, 0x6797, 0x6DCB, 0x71D0, 0x7433, 0x81E8, 0x8F2A, + 0x96A3, 0x9C57, 0x9E9F, 0x7460, 0x5841, 0x6D99, 0x7D2F, 0x985E, + 0x4EE4, 0x4F36, 0x4F8B, 0x51B7, 0x52B1, 0x5DBA, 0x601C, 0x73B2, + 0x793C, 0x82D3, 0x9234, 0x96B7, 0x96F6, 0x970A, 0x9E97, 0x9F62, + 0x66A6, 0x6B74, 0x5217, 0x52A3, 0x70C8, 0x88C2, 0x5EC9, 0x604B, + 0x6190, 0x6F23, 0x7149, 0x7C3E, 0x7DF4, 0x806F + }, + { /* category 47 */ + 0x84EE, 0x9023, 0x932C, 0x5442, 0x9B6F, 0x6AD3, 0x7089, 0x8CC2, + 0x8DEF, 0x9732, 0x52B4, 0x5A41, 0x5ECA, 0x5F04, 0x6717, 0x697C, + 0x6994, 0x6D6A, 0x6F0F, 0x7262, 0x72FC, 0x7BED, 0x8001, 0x807E, + 0x874B, 0x90CE, 0x516D, 0x9E93, 0x7984, 0x808B, 0x9332, 0x8AD6, + 0x502D, 0x548C, 0x8A71, 0x6B6A, 0x8CC4, 0x8107, 0x60D1, 0x67A0, + 0x9DF2, 0x4E99, 0x4E98, 0x9C10, 0x8A6B, 0x85C1, 0x8568, 0x6900, + 0x6E7E, 0x7897, 0x8155, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 48 */ + 0x5F0C, 0x4E10, 0x4E15, 0x4E2A, 0x4E31, 0x4E36, 0x4E3C, 0x4E3F, + 0x4E42, 0x4E56, 0x4E58, 0x4E82, 0x4E85, 0x8C6B, 0x4E8A, 0x8212, + 0x5F0D, 0x4E8E, 0x4E9E, 0x4E9F, 0x4EA0, 0x4EA2, 0x4EB0, 0x4EB3, + 0x4EB6, 0x4ECE, 0x4ECD, 0x4EC4, 0x4EC6, 0x4EC2, 0x4ED7, 0x4EDE, + 0x4EED, 0x4EDF, 0x4EF7, 0x4F09, 0x4F5A, 0x4F30, 0x4F5B, 0x4F5D, + 0x4F57, 0x4F47, 0x4F76, 0x4F88, 0x4F8F, 0x4F98, 0x4F7B, 0x4F69, + 0x4F70, 0x4F91, 0x4F6F, 0x4F86, 0x4F96, 0x5118, 0x4FD4, 0x4FDF, + 0x4FCE, 0x4FD8, 0x4FDB, 0x4FD1, 0x4FDA, 0x4FD0, 0x4FE4, 0x4FE5, + 0x501A, 0x5028, 0x5014, 0x502A, 0x5025, 0x5005, 0x4F1C, 0x4FF6, + 0x5021, 0x5029, 0x502C, 0x4FFE, 0x4FEF, 0x5011, 0x5006, 0x5043, + 0x5047, 0x6703, 0x5055, 0x5050, 0x5048, 0x505A, 0x5056, 0x506C, + 0x5078, 0x5080, 0x509A, 0x5085, 0x50B4, 0x50B2 + }, + { /* category 49 */ + 0x50C9, 0x50CA, 0x50B3, 0x50C2, 0x50D6, 0x50DE, 0x50E5, 0x50ED, + 0x50E3, 0x50EE, 0x50F9, 0x50F5, 0x5109, 0x5101, 0x5102, 0x5116, + 0x5115, 0x5114, 0x511A, 0x5121, 0x513A, 0x5137, 0x513C, 0x513B, + 0x513F, 0x5140, 0x5152, 0x514C, 0x5154, 0x5162, 0x7AF8, 0x5169, + 0x516A, 0x516E, 0x5180, 0x5182, 0x56D8, 0x518C, 0x5189, 0x518F, + 0x5191, 0x5193, 0x5195, 0x5196, 0x51A4, 0x51A6, 0x51A2, 0x51A9, + 0x51AA, 0x51AB, 0x51B3, 0x51B1, 0x51B2, 0x51B0, 0x51B5, 0x51BD, + 0x51C5, 0x51C9, 0x51DB, 0x51E0, 0x8655, 0x51E9, 0x51ED, 0x51F0, + 0x51F5, 0x51FE, 0x5204, 0x520B, 0x5214, 0x520E, 0x5227, 0x522A, + 0x522E, 0x5233, 0x5239, 0x524F, 0x5244, 0x524B, 0x524C, 0x525E, + 0x5254, 0x526A, 0x5274, 0x5269, 0x5273, 0x527F, 0x527D, 0x528D, + 0x5294, 0x5292, 0x5271, 0x5288, 0x5291, 0x8FA8 + }, + { /* category 50 */ + 0x8FA7, 0x52AC, 0x52AD, 0x52BC, 0x52B5, 0x52C1, 0x52CD, 0x52D7, + 0x52DE, 0x52E3, 0x52E6, 0x98ED, 0x52E0, 0x52F3, 0x52F5, 0x52F8, + 0x52F9, 0x5306, 0x5308, 0x7538, 0x530D, 0x5310, 0x530F, 0x5315, + 0x531A, 0x5323, 0x532F, 0x5331, 0x5333, 0x5338, 0x5340, 0x5346, + 0x5345, 0x4E17, 0x5349, 0x534D, 0x51D6, 0x535E, 0x5369, 0x536E, + 0x5918, 0x537B, 0x5377, 0x5382, 0x5396, 0x53A0, 0x53A6, 0x53A5, + 0x53AE, 0x53B0, 0x53B6, 0x53C3, 0x7C12, 0x96D9, 0x53DF, 0x66FC, + 0x71EE, 0x53EE, 0x53E8, 0x53ED, 0x53FA, 0x5401, 0x543D, 0x5440, + 0x542C, 0x542D, 0x543C, 0x542E, 0x5436, 0x5429, 0x541D, 0x544E, + 0x548F, 0x5475, 0x548E, 0x545F, 0x5471, 0x5477, 0x5470, 0x5492, + 0x547B, 0x5480, 0x5476, 0x5484, 0x5490, 0x5486, 0x54C7, 0x54A2, + 0x54B8, 0x54A5, 0x54AC, 0x54C4, 0x54C8, 0x54A8 + }, + { /* category 51 */ + 0x54AB, 0x54C2, 0x54A4, 0x54BE, 0x54BC, 0x54D8, 0x54E5, 0x54E6, + 0x550F, 0x5514, 0x54FD, 0x54EE, 0x54ED, 0x54FA, 0x54E2, 0x5539, + 0x5540, 0x5563, 0x554C, 0x552E, 0x555C, 0x5545, 0x5556, 0x5557, + 0x5538, 0x5533, 0x555D, 0x5599, 0x5580, 0x54AF, 0x558A, 0x559F, + 0x557B, 0x557E, 0x5598, 0x559E, 0x55AE, 0x557C, 0x5583, 0x55A9, + 0x5587, 0x55A8, 0x55DA, 0x55C5, 0x55DF, 0x55C4, 0x55DC, 0x55E4, + 0x55D4, 0x5614, 0x55F7, 0x5616, 0x55FE, 0x55FD, 0x561B, 0x55F9, + 0x564E, 0x5650, 0x71DF, 0x5634, 0x5636, 0x5632, 0x5638, 0x566B, + 0x5664, 0x562F, 0x566C, 0x566A, 0x5686, 0x5680, 0x568A, 0x56A0, + 0x5694, 0x568F, 0x56A5, 0x56AE, 0x56B6, 0x56B4, 0x56C2, 0x56BC, + 0x56C1, 0x56C3, 0x56C0, 0x56C8, 0x56CE, 0x56D1, 0x56D3, 0x56D7, + 0x56EE, 0x56F9, 0x5700, 0x56FF, 0x5704, 0x5709 + }, + { /* category 52 */ + 0x5708, 0x570B, 0x570D, 0x5713, 0x5718, 0x5716, 0x55C7, 0x571C, + 0x5726, 0x5737, 0x5738, 0x574E, 0x573B, 0x5740, 0x574F, 0x5769, + 0x57C0, 0x5788, 0x5761, 0x577F, 0x5789, 0x5793, 0x57A0, 0x57B3, + 0x57A4, 0x57AA, 0x57B0, 0x57C3, 0x57C6, 0x57D4, 0x57D2, 0x57D3, + 0x580A, 0x57D6, 0x57E3, 0x580B, 0x5819, 0x581D, 0x5872, 0x5821, + 0x5862, 0x584B, 0x5870, 0x6BC0, 0x5852, 0x583D, 0x5879, 0x5885, + 0x58B9, 0x589F, 0x58AB, 0x58BA, 0x58DE, 0x58BB, 0x58B8, 0x58AE, + 0x58C5, 0x58D3, 0x58D1, 0x58D7, 0x58D9, 0x58D8, 0x58E5, 0x58DC, + 0x58E4, 0x58DF, 0x58EF, 0x58FA, 0x58F9, 0x58FB, 0x58FC, 0x58FD, + 0x5902, 0x590A, 0x5910, 0x591B, 0x68A6, 0x5925, 0x592C, 0x592D, + 0x5932, 0x5938, 0x593E, 0x7AD2, 0x5955, 0x5950, 0x594E, 0x595A, + 0x5958, 0x5962, 0x5960, 0x5967, 0x596C, 0x5969 + }, + { /* category 53 */ + 0x5978, 0x5981, 0x599D, 0x4F5E, 0x4FAB, 0x59A3, 0x59B2, 0x59C6, + 0x59E8, 0x59DC, 0x598D, 0x59D9, 0x59DA, 0x5A25, 0x5A1F, 0x5A11, + 0x5A1C, 0x5A09, 0x5A1A, 0x5A40, 0x5A6C, 0x5A49, 0x5A35, 0x5A36, + 0x5A62, 0x5A6A, 0x5A9A, 0x5ABC, 0x5ABE, 0x5ACB, 0x5AC2, 0x5ABD, + 0x5AE3, 0x5AD7, 0x5AE6, 0x5AE9, 0x5AD6, 0x5AFA, 0x5AFB, 0x5B0C, + 0x5B0B, 0x5B16, 0x5B32, 0x5AD0, 0x5B2A, 0x5B36, 0x5B3E, 0x5B43, + 0x5B45, 0x5B40, 0x5B51, 0x5B55, 0x5B5A, 0x5B5B, 0x5B65, 0x5B69, + 0x5B70, 0x5B73, 0x5B75, 0x5B78, 0x6588, 0x5B7A, 0x5B80, 0x5B83, + 0x5BA6, 0x5BB8, 0x5BC3, 0x5BC7, 0x5BC9, 0x5BD4, 0x5BD0, 0x5BE4, + 0x5BE6, 0x5BE2, 0x5BDE, 0x5BE5, 0x5BEB, 0x5BF0, 0x5BF6, 0x5BF3, + 0x5C05, 0x5C07, 0x5C08, 0x5C0D, 0x5C13, 0x5C20, 0x5C22, 0x5C28, + 0x5C38, 0x5C39, 0x5C41, 0x5C46, 0x5C4E, 0x5C53 + }, + { /* category 54 */ + 0x5C50, 0x5C4F, 0x5B71, 0x5C6C, 0x5C6E, 0x4E62, 0x5C76, 0x5C79, + 0x5C8C, 0x5C91, 0x5C94, 0x599B, 0x5CAB, 0x5CBB, 0x5CB6, 0x5CBC, + 0x5CB7, 0x5CC5, 0x5CBE, 0x5CC7, 0x5CD9, 0x5CE9, 0x5CFD, 0x5CFA, + 0x5CED, 0x5D8C, 0x5CEA, 0x5D0B, 0x5D15, 0x5D17, 0x5D5C, 0x5D1F, + 0x5D1B, 0x5D11, 0x5D14, 0x5D22, 0x5D1A, 0x5D19, 0x5D18, 0x5D4C, + 0x5D52, 0x5D4E, 0x5D4B, 0x5D6C, 0x5D73, 0x5D76, 0x5D87, 0x5D84, + 0x5D82, 0x5DA2, 0x5D9D, 0x5DAC, 0x5DAE, 0x5DBD, 0x5D90, 0x5DB7, + 0x5DBC, 0x5DC9, 0x5DCD, 0x5DD3, 0x5DD2, 0x5DD6, 0x5DDB, 0x5DEB, + 0x5DF2, 0x5DF5, 0x5E0B, 0x5E1A, 0x5E19, 0x5E11, 0x5E1B, 0x5E36, + 0x5E37, 0x5E44, 0x5E43, 0x5E40, 0x5E4E, 0x5E57, 0x5E54, 0x5E5F, + 0x5E62, 0x5E64, 0x5E47, 0x5E75, 0x5E76, 0x5E7A, 0x9EBC, 0x5E7F, + 0x5EA0, 0x5EC1, 0x5EC2, 0x5EC8, 0x5ED0, 0x5ECF + }, + { /* category 55 */ + 0x5ED6, 0x5EE3, 0x5EDD, 0x5EDA, 0x5EDB, 0x5EE2, 0x5EE1, 0x5EE8, + 0x5EE9, 0x5EEC, 0x5EF1, 0x5EF3, 0x5EF0, 0x5EF4, 0x5EF8, 0x5EFE, + 0x5F03, 0x5F09, 0x5F5D, 0x5F5C, 0x5F0B, 0x5F11, 0x5F16, 0x5F29, + 0x5F2D, 0x5F38, 0x5F41, 0x5F48, 0x5F4C, 0x5F4E, 0x5F2F, 0x5F51, + 0x5F56, 0x5F57, 0x5F59, 0x5F61, 0x5F6D, 0x5F73, 0x5F77, 0x5F83, + 0x5F82, 0x5F7F, 0x5F8A, 0x5F88, 0x5F91, 0x5F87, 0x5F9E, 0x5F99, + 0x5F98, 0x5FA0, 0x5FA8, 0x5FAD, 0x5FBC, 0x5FD6, 0x5FFB, 0x5FE4, + 0x5FF8, 0x5FF1, 0x5FDD, 0x60B3, 0x5FFF, 0x6021, 0x6060, 0x6019, + 0x6010, 0x6029, 0x600E, 0x6031, 0x601B, 0x6015, 0x602B, 0x6026, + 0x600F, 0x603A, 0x605A, 0x6041, 0x606A, 0x6077, 0x605F, 0x604A, + 0x6046, 0x604D, 0x6063, 0x6043, 0x6064, 0x6042, 0x606C, 0x606B, + 0x6059, 0x6081, 0x608D, 0x60E7, 0x6083, 0x609A + }, + { /* category 56 */ + 0x6084, 0x609B, 0x6096, 0x6097, 0x6092, 0x60A7, 0x608B, 0x60E1, + 0x60B8, 0x60E0, 0x60D3, 0x60B4, 0x5FF0, 0x60BD, 0x60C6, 0x60B5, + 0x60D8, 0x614D, 0x6115, 0x6106, 0x60F6, 0x60F7, 0x6100, 0x60F4, + 0x60FA, 0x6103, 0x6121, 0x60FB, 0x60F1, 0x610D, 0x610E, 0x6147, + 0x613E, 0x6128, 0x6127, 0x614A, 0x613F, 0x613C, 0x612C, 0x6134, + 0x613D, 0x6142, 0x6144, 0x6173, 0x6177, 0x6158, 0x6159, 0x615A, + 0x616B, 0x6174, 0x616F, 0x6165, 0x6171, 0x615F, 0x615D, 0x6153, + 0x6175, 0x6199, 0x6196, 0x6187, 0x61AC, 0x6194, 0x619A, 0x618A, + 0x6191, 0x61AB, 0x61AE, 0x61CC, 0x61CA, 0x61C9, 0x61F7, 0x61C8, + 0x61C3, 0x61C6, 0x61BA, 0x61CB, 0x7F79, 0x61CD, 0x61E6, 0x61E3, + 0x61F6, 0x61FA, 0x61F4, 0x61FF, 0x61FD, 0x61FC, 0x61FE, 0x6200, + 0x6208, 0x6209, 0x620D, 0x620C, 0x6214, 0x621B + }, + { /* category 57 */ + 0x621E, 0x6221, 0x622A, 0x622E, 0x6230, 0x6232, 0x6233, 0x6241, + 0x624E, 0x625E, 0x6263, 0x625B, 0x6260, 0x6268, 0x627C, 0x6282, + 0x6289, 0x627E, 0x6292, 0x6293, 0x6296, 0x62D4, 0x6283, 0x6294, + 0x62D7, 0x62D1, 0x62BB, 0x62CF, 0x62FF, 0x62C6, 0x64D4, 0x62C8, + 0x62DC, 0x62CC, 0x62CA, 0x62C2, 0x62C7, 0x629B, 0x62C9, 0x630C, + 0x62EE, 0x62F1, 0x6327, 0x6302, 0x6308, 0x62EF, 0x62F5, 0x6350, + 0x633E, 0x634D, 0x641C, 0x634F, 0x6396, 0x638E, 0x6380, 0x63AB, + 0x6376, 0x63A3, 0x638F, 0x6389, 0x639F, 0x63B5, 0x636B, 0x6369, + 0x63BE, 0x63E9, 0x63C0, 0x63C6, 0x63E3, 0x63C9, 0x63D2, 0x63F6, + 0x63C4, 0x6416, 0x6434, 0x6406, 0x6413, 0x6426, 0x6436, 0x651D, + 0x6417, 0x6428, 0x640F, 0x6467, 0x646F, 0x6476, 0x644E, 0x652A, + 0x6495, 0x6493, 0x64A5, 0x64A9, 0x6488, 0x64BC + }, + { /* category 58 */ + 0x64DA, 0x64D2, 0x64C5, 0x64C7, 0x64BB, 0x64D8, 0x64C2, 0x64F1, + 0x64E7, 0x8209, 0x64E0, 0x64E1, 0x62AC, 0x64E3, 0x64EF, 0x652C, + 0x64F6, 0x64F4, 0x64F2, 0x64FA, 0x6500, 0x64FD, 0x6518, 0x651C, + 0x6505, 0x6524, 0x6523, 0x652B, 0x6534, 0x6535, 0x6537, 0x6536, + 0x6538, 0x754B, 0x6548, 0x6556, 0x6555, 0x654D, 0x6558, 0x655E, + 0x655D, 0x6572, 0x6578, 0x6582, 0x6583, 0x8B8A, 0x659B, 0x659F, + 0x65AB, 0x65B7, 0x65C3, 0x65C6, 0x65C1, 0x65C4, 0x65CC, 0x65D2, + 0x65DB, 0x65D9, 0x65E0, 0x65E1, 0x65F1, 0x6772, 0x660A, 0x6603, + 0x65FB, 0x6773, 0x6635, 0x6636, 0x6634, 0x661C, 0x664F, 0x6644, + 0x6649, 0x6641, 0x665E, 0x665D, 0x6664, 0x6667, 0x6668, 0x665F, + 0x6662, 0x6670, 0x6683, 0x6688, 0x668E, 0x6689, 0x6684, 0x6698, + 0x669D, 0x66C1, 0x66B9, 0x66C9, 0x66BE, 0x66BC + }, + { /* category 59 */ + 0x66C4, 0x66B8, 0x66D6, 0x66DA, 0x66E0, 0x663F, 0x66E6, 0x66E9, + 0x66F0, 0x66F5, 0x66F7, 0x670F, 0x6716, 0x671E, 0x6726, 0x6727, + 0x9738, 0x672E, 0x673F, 0x6736, 0x6741, 0x6738, 0x6737, 0x6746, + 0x675E, 0x6760, 0x6759, 0x6763, 0x6764, 0x6789, 0x6770, 0x67A9, + 0x677C, 0x676A, 0x678C, 0x678B, 0x67A6, 0x67A1, 0x6785, 0x67B7, + 0x67EF, 0x67B4, 0x67EC, 0x67B3, 0x67E9, 0x67B8, 0x67E4, 0x67DE, + 0x67DD, 0x67E2, 0x67EE, 0x67B9, 0x67CE, 0x67C6, 0x67E7, 0x6A9C, + 0x681E, 0x6846, 0x6829, 0x6840, 0x684D, 0x6832, 0x684E, 0x68B3, + 0x682B, 0x6859, 0x6863, 0x6877, 0x687F, 0x689F, 0x688F, 0x68AD, + 0x6894, 0x689D, 0x689B, 0x6883, 0x6AAE, 0x68B9, 0x6874, 0x68B5, + 0x68A0, 0x68BA, 0x690F, 0x688D, 0x687E, 0x6901, 0x68CA, 0x6908, + 0x68D8, 0x6922, 0x6926, 0x68E1, 0x690C, 0x68CD + }, + { /* category 60 */ + 0x68D4, 0x68E7, 0x68D5, 0x6936, 0x6912, 0x6904, 0x68D7, 0x68E3, + 0x6925, 0x68F9, 0x68E0, 0x68EF, 0x6928, 0x692A, 0x691A, 0x6923, + 0x6921, 0x68C6, 0x6979, 0x6977, 0x695C, 0x6978, 0x696B, 0x6954, + 0x697E, 0x696E, 0x6939, 0x6974, 0x693D, 0x6959, 0x6930, 0x6961, + 0x695E, 0x695D, 0x6981, 0x696A, 0x69B2, 0x69AE, 0x69D0, 0x69BF, + 0x69C1, 0x69D3, 0x69BE, 0x69CE, 0x5BE8, 0x69CA, 0x69DD, 0x69BB, + 0x69C3, 0x69A7, 0x6A2E, 0x6991, 0x69A0, 0x699C, 0x6995, 0x69B4, + 0x69DE, 0x69E8, 0x6A02, 0x6A1B, 0x69FF, 0x6B0A, 0x69F9, 0x69F2, + 0x69E7, 0x6A05, 0x69B1, 0x6A1E, 0x69ED, 0x6A14, 0x69EB, 0x6A0A, + 0x6A12, 0x6AC1, 0x6A23, 0x6A13, 0x6A44, 0x6A0C, 0x6A72, 0x6A36, + 0x6A78, 0x6A47, 0x6A62, 0x6A59, 0x6A66, 0x6A48, 0x6A38, 0x6A22, + 0x6A90, 0x6A8D, 0x6AA0, 0x6A84, 0x6AA2, 0x6AA3 + }, + { /* category 61 */ + 0x6A97, 0x8617, 0x6ABB, 0x6AC3, 0x6AC2, 0x6AB8, 0x6AB3, 0x6AAC, + 0x6ADE, 0x6AD1, 0x6ADF, 0x6AAA, 0x6ADA, 0x6AEA, 0x6AFB, 0x6B05, + 0x8616, 0x6AFA, 0x6B12, 0x6B16, 0x9B31, 0x6B1F, 0x6B38, 0x6B37, + 0x76DC, 0x6B39, 0x98EE, 0x6B47, 0x6B43, 0x6B49, 0x6B50, 0x6B59, + 0x6B54, 0x6B5B, 0x6B5F, 0x6B61, 0x6B78, 0x6B79, 0x6B7F, 0x6B80, + 0x6B84, 0x6B83, 0x6B8D, 0x6B98, 0x6B95, 0x6B9E, 0x6BA4, 0x6BAA, + 0x6BAB, 0x6BAF, 0x6BB2, 0x6BB1, 0x6BB3, 0x6BB7, 0x6BBC, 0x6BC6, + 0x6BCB, 0x6BD3, 0x6BDF, 0x6BEC, 0x6BEB, 0x6BF3, 0x6BEF, 0x9EBE, + 0x6C08, 0x6C13, 0x6C14, 0x6C1B, 0x6C24, 0x6C23, 0x6C5E, 0x6C55, + 0x6C62, 0x6C6A, 0x6C82, 0x6C8D, 0x6C9A, 0x6C81, 0x6C9B, 0x6C7E, + 0x6C68, 0x6C73, 0x6C92, 0x6C90, 0x6CC4, 0x6CF1, 0x6CD3, 0x6CBD, + 0x6CD7, 0x6CC5, 0x6CDD, 0x6CAE, 0x6CB1, 0x6CBE + }, + { /* category 62 */ + 0x6CBA, 0x6CDB, 0x6CEF, 0x6CD9, 0x6CEA, 0x6D1F, 0x884D, 0x6D36, + 0x6D2B, 0x6D3D, 0x6D38, 0x6D19, 0x6D35, 0x6D33, 0x6D12, 0x6D0C, + 0x6D63, 0x6D93, 0x6D64, 0x6D5A, 0x6D79, 0x6D59, 0x6D8E, 0x6D95, + 0x6FE4, 0x6D85, 0x6DF9, 0x6E15, 0x6E0A, 0x6DB5, 0x6DC7, 0x6DE6, + 0x6DB8, 0x6DC6, 0x6DEC, 0x6DDE, 0x6DCC, 0x6DE8, 0x6DD2, 0x6DC5, + 0x6DFA, 0x6DD9, 0x6DE4, 0x6DD5, 0x6DEA, 0x6DEE, 0x6E2D, 0x6E6E, + 0x6E2E, 0x6E19, 0x6E72, 0x6E5F, 0x6E3E, 0x6E23, 0x6E6B, 0x6E2B, + 0x6E76, 0x6E4D, 0x6E1F, 0x6E43, 0x6E3A, 0x6E4E, 0x6E24, 0x6EFF, + 0x6E1D, 0x6E38, 0x6E82, 0x6EAA, 0x6E98, 0x6EC9, 0x6EB7, 0x6ED3, + 0x6EBD, 0x6EAF, 0x6EC4, 0x6EB2, 0x6ED4, 0x6ED5, 0x6E8F, 0x6EA5, + 0x6EC2, 0x6E9F, 0x6F41, 0x6F11, 0x704C, 0x6EEC, 0x6EF8, 0x6EFE, + 0x6F3F, 0x6EF2, 0x6F31, 0x6EEF, 0x6F32, 0x6ECC + }, + { /* category 63 */ + 0x6F3E, 0x6F13, 0x6EF7, 0x6F86, 0x6F7A, 0x6F78, 0x6F81, 0x6F80, + 0x6F6F, 0x6F5B, 0x6FF3, 0x6F6D, 0x6F82, 0x6F7C, 0x6F58, 0x6F8E, + 0x6F91, 0x6FC2, 0x6F66, 0x6FB3, 0x6FA3, 0x6FA1, 0x6FA4, 0x6FB9, + 0x6FC6, 0x6FAA, 0x6FDF, 0x6FD5, 0x6FEC, 0x6FD4, 0x6FD8, 0x6FF1, + 0x6FEE, 0x6FDB, 0x7009, 0x700B, 0x6FFA, 0x7011, 0x7001, 0x700F, + 0x6FFE, 0x701B, 0x701A, 0x6F74, 0x701D, 0x7018, 0x701F, 0x7030, + 0x703E, 0x7032, 0x7051, 0x7063, 0x7099, 0x7092, 0x70AF, 0x70F1, + 0x70AC, 0x70B8, 0x70B3, 0x70AE, 0x70DF, 0x70CB, 0x70DD, 0x70D9, + 0x7109, 0x70FD, 0x711C, 0x7119, 0x7165, 0x7155, 0x7188, 0x7166, + 0x7162, 0x714C, 0x7156, 0x716C, 0x718F, 0x71FB, 0x7184, 0x7195, + 0x71A8, 0x71AC, 0x71D7, 0x71B9, 0x71BE, 0x71D2, 0x71C9, 0x71D4, + 0x71CE, 0x71E0, 0x71EC, 0x71E7, 0x71F5, 0x71FC + }, + { /* category 64 */ + 0x71F9, 0x71FF, 0x720D, 0x7210, 0x721B, 0x7228, 0x722D, 0x722C, + 0x7230, 0x7232, 0x723B, 0x723C, 0x723F, 0x7240, 0x7246, 0x724B, + 0x7258, 0x7274, 0x727E, 0x7282, 0x7281, 0x7287, 0x7292, 0x7296, + 0x72A2, 0x72A7, 0x72B9, 0x72B2, 0x72C3, 0x72C6, 0x72C4, 0x72CE, + 0x72D2, 0x72E2, 0x72E0, 0x72E1, 0x72F9, 0x72F7, 0x500F, 0x7317, + 0x730A, 0x731C, 0x7316, 0x731D, 0x7334, 0x732F, 0x7329, 0x7325, + 0x733E, 0x734E, 0x734F, 0x9ED8, 0x7357, 0x736A, 0x7368, 0x7370, + 0x7378, 0x7375, 0x737B, 0x737A, 0x73C8, 0x73B3, 0x73CE, 0x73BB, + 0x73C0, 0x73E5, 0x73EE, 0x73DE, 0x74A2, 0x7405, 0x746F, 0x7425, + 0x73F8, 0x7432, 0x743A, 0x7455, 0x743F, 0x745F, 0x7459, 0x7441, + 0x745C, 0x7469, 0x7470, 0x7463, 0x746A, 0x7476, 0x747E, 0x748B, + 0x749E, 0x74A7, 0x74CA, 0x74CF, 0x74D4, 0x73F1 + }, + { /* category 65 */ + 0x74E0, 0x74E3, 0x74E7, 0x74E9, 0x74EE, 0x74F2, 0x74F0, 0x74F1, + 0x74F8, 0x74F7, 0x7504, 0x7503, 0x7505, 0x750C, 0x750E, 0x750D, + 0x7515, 0x7513, 0x751E, 0x7526, 0x752C, 0x753C, 0x7544, 0x754D, + 0x754A, 0x7549, 0x755B, 0x7546, 0x755A, 0x7569, 0x7564, 0x7567, + 0x756B, 0x756D, 0x7578, 0x7576, 0x7586, 0x7587, 0x7574, 0x758A, + 0x7589, 0x7582, 0x7594, 0x759A, 0x759D, 0x75A5, 0x75A3, 0x75C2, + 0x75B3, 0x75C3, 0x75B5, 0x75BD, 0x75B8, 0x75BC, 0x75B1, 0x75CD, + 0x75CA, 0x75D2, 0x75D9, 0x75E3, 0x75DE, 0x75FE, 0x75FF, 0x75FC, + 0x7601, 0x75F0, 0x75FA, 0x75F2, 0x75F3, 0x760B, 0x760D, 0x7609, + 0x761F, 0x7627, 0x7620, 0x7621, 0x7622, 0x7624, 0x7634, 0x7630, + 0x763B, 0x7647, 0x7648, 0x7646, 0x765C, 0x7658, 0x7661, 0x7662, + 0x7668, 0x7669, 0x766A, 0x7667, 0x766C, 0x7670 + }, + { /* category 66 */ + 0x7672, 0x7676, 0x7678, 0x767C, 0x7680, 0x7683, 0x7688, 0x768B, + 0x768E, 0x7696, 0x7693, 0x7699, 0x769A, 0x76B0, 0x76B4, 0x76B8, + 0x76B9, 0x76BA, 0x76C2, 0x76CD, 0x76D6, 0x76D2, 0x76DE, 0x76E1, + 0x76E5, 0x76E7, 0x76EA, 0x862F, 0x76FB, 0x7708, 0x7707, 0x7704, + 0x7729, 0x7724, 0x771E, 0x7725, 0x7726, 0x771B, 0x7737, 0x7738, + 0x7747, 0x775A, 0x7768, 0x776B, 0x775B, 0x7765, 0x777F, 0x777E, + 0x7779, 0x778E, 0x778B, 0x7791, 0x77A0, 0x779E, 0x77B0, 0x77B6, + 0x77B9, 0x77BF, 0x77BC, 0x77BD, 0x77BB, 0x77C7, 0x77CD, 0x77D7, + 0x77DA, 0x77DC, 0x77E3, 0x77EE, 0x77FC, 0x780C, 0x7812, 0x7926, + 0x7820, 0x792A, 0x7845, 0x788E, 0x7874, 0x7886, 0x787C, 0x789A, + 0x788C, 0x78A3, 0x78B5, 0x78AA, 0x78AF, 0x78D1, 0x78C6, 0x78CB, + 0x78D4, 0x78BE, 0x78BC, 0x78C5, 0x78CA, 0x78EC + }, + { /* category 67 */ + 0x78E7, 0x78DA, 0x78FD, 0x78F4, 0x7907, 0x7912, 0x7911, 0x7919, + 0x792C, 0x792B, 0x7940, 0x7960, 0x7957, 0x795F, 0x795A, 0x7955, + 0x7953, 0x797A, 0x797F, 0x798A, 0x799D, 0x79A7, 0x9F4B, 0x79AA, + 0x79AE, 0x79B3, 0x79B9, 0x79BA, 0x79C9, 0x79D5, 0x79E7, 0x79EC, + 0x79E1, 0x79E3, 0x7A08, 0x7A0D, 0x7A18, 0x7A19, 0x7A20, 0x7A1F, + 0x7980, 0x7A31, 0x7A3B, 0x7A3E, 0x7A37, 0x7A43, 0x7A57, 0x7A49, + 0x7A61, 0x7A62, 0x7A69, 0x9F9D, 0x7A70, 0x7A79, 0x7A7D, 0x7A88, + 0x7A97, 0x7A95, 0x7A98, 0x7A96, 0x7AA9, 0x7AC8, 0x7AB0, 0x7AB6, + 0x7AC5, 0x7AC4, 0x7ABF, 0x9083, 0x7AC7, 0x7ACA, 0x7ACD, 0x7ACF, + 0x7AD5, 0x7AD3, 0x7AD9, 0x7ADA, 0x7ADD, 0x7AE1, 0x7AE2, 0x7AE6, + 0x7AED, 0x7AF0, 0x7B02, 0x7B0F, 0x7B0A, 0x7B06, 0x7B33, 0x7B18, + 0x7B19, 0x7B1E, 0x7B35, 0x7B28, 0x7B36, 0x7B50 + }, + { /* category 68 */ + 0x7B7A, 0x7B04, 0x7B4D, 0x7B0B, 0x7B4C, 0x7B45, 0x7B75, 0x7B65, + 0x7B74, 0x7B67, 0x7B70, 0x7B71, 0x7B6C, 0x7B6E, 0x7B9D, 0x7B98, + 0x7B9F, 0x7B8D, 0x7B9C, 0x7B9A, 0x7B8B, 0x7B92, 0x7B8F, 0x7B5D, + 0x7B99, 0x7BCB, 0x7BC1, 0x7BCC, 0x7BCF, 0x7BB4, 0x7BC6, 0x7BDD, + 0x7BE9, 0x7C11, 0x7C14, 0x7BE6, 0x7BE5, 0x7C60, 0x7C00, 0x7C07, + 0x7C13, 0x7BF3, 0x7BF7, 0x7C17, 0x7C0D, 0x7BF6, 0x7C23, 0x7C27, + 0x7C2A, 0x7C1F, 0x7C37, 0x7C2B, 0x7C3D, 0x7C4C, 0x7C43, 0x7C54, + 0x7C4F, 0x7C40, 0x7C50, 0x7C58, 0x7C5F, 0x7C64, 0x7C56, 0x7C65, + 0x7C6C, 0x7C75, 0x7C83, 0x7C90, 0x7CA4, 0x7CAD, 0x7CA2, 0x7CAB, + 0x7CA1, 0x7CA8, 0x7CB3, 0x7CB2, 0x7CB1, 0x7CAE, 0x7CB9, 0x7CBD, + 0x7CC0, 0x7CC5, 0x7CC2, 0x7CD8, 0x7CD2, 0x7CDC, 0x7CE2, 0x9B3B, + 0x7CEF, 0x7CF2, 0x7CF4, 0x7CF6, 0x7CFA, 0x7D06 + }, + { /* category 69 */ + 0x7D02, 0x7D1C, 0x7D15, 0x7D0A, 0x7D45, 0x7D4B, 0x7D2E, 0x7D32, + 0x7D3F, 0x7D35, 0x7D46, 0x7D73, 0x7D56, 0x7D4E, 0x7D72, 0x7D68, + 0x7D6E, 0x7D4F, 0x7D63, 0x7D93, 0x7D89, 0x7D5B, 0x7D8F, 0x7D7D, + 0x7D9B, 0x7DBA, 0x7DAE, 0x7DA3, 0x7DB5, 0x7DC7, 0x7DBD, 0x7DAB, + 0x7E3D, 0x7DA2, 0x7DAF, 0x7DDC, 0x7DB8, 0x7D9F, 0x7DB0, 0x7DD8, + 0x7DDD, 0x7DE4, 0x7DDE, 0x7DFB, 0x7DF2, 0x7DE1, 0x7E05, 0x7E0A, + 0x7E23, 0x7E21, 0x7E12, 0x7E31, 0x7E1F, 0x7E09, 0x7E0B, 0x7E22, + 0x7E46, 0x7E66, 0x7E3B, 0x7E35, 0x7E39, 0x7E43, 0x7E37, 0x7E32, + 0x7E3A, 0x7E67, 0x7E5D, 0x7E56, 0x7E5E, 0x7E59, 0x7E5A, 0x7E79, + 0x7E6A, 0x7E69, 0x7E7C, 0x7E7B, 0x7E83, 0x7DD5, 0x7E7D, 0x8FAE, + 0x7E7F, 0x7E88, 0x7E89, 0x7E8C, 0x7E92, 0x7E90, 0x7E93, 0x7E94, + 0x7E96, 0x7E8E, 0x7E9B, 0x7E9C, 0x7F38, 0x7F3A + }, + { /* category 70 */ + 0x7F45, 0x7F4C, 0x7F4D, 0x7F4E, 0x7F50, 0x7F51, 0x7F55, 0x7F54, + 0x7F58, 0x7F5F, 0x7F60, 0x7F68, 0x7F69, 0x7F67, 0x7F78, 0x7F82, + 0x7F86, 0x7F83, 0x7F88, 0x7F87, 0x7F8C, 0x7F94, 0x7F9E, 0x7F9D, + 0x7F9A, 0x7FA3, 0x7FAF, 0x7FB2, 0x7FB9, 0x7FAE, 0x7FB6, 0x7FB8, + 0x8B71, 0x7FC5, 0x7FC6, 0x7FCA, 0x7FD5, 0x7FD4, 0x7FE1, 0x7FE6, + 0x7FE9, 0x7FF3, 0x7FF9, 0x98DC, 0x8006, 0x8004, 0x800B, 0x8012, + 0x8018, 0x8019, 0x801C, 0x8021, 0x8028, 0x803F, 0x803B, 0x804A, + 0x8046, 0x8052, 0x8058, 0x805A, 0x805F, 0x8062, 0x8068, 0x8073, + 0x8072, 0x8070, 0x8076, 0x8079, 0x807D, 0x807F, 0x8084, 0x8086, + 0x8085, 0x809B, 0x8093, 0x809A, 0x80AD, 0x5190, 0x80AC, 0x80DB, + 0x80E5, 0x80D9, 0x80DD, 0x80C4, 0x80DA, 0x80D6, 0x8109, 0x80EF, + 0x80F1, 0x811B, 0x8129, 0x8123, 0x812F, 0x814B + }, + { /* category 71 */ + 0x968B, 0x8146, 0x813E, 0x8153, 0x8151, 0x80FC, 0x8171, 0x816E, + 0x8165, 0x8166, 0x8174, 0x8183, 0x8188, 0x818A, 0x8180, 0x8182, + 0x81A0, 0x8195, 0x81A4, 0x81A3, 0x815F, 0x8193, 0x81A9, 0x81B0, + 0x81B5, 0x81BE, 0x81B8, 0x81BD, 0x81C0, 0x81C2, 0x81BA, 0x81C9, + 0x81CD, 0x81D1, 0x81D9, 0x81D8, 0x81C8, 0x81DA, 0x81DF, 0x81E0, + 0x81E7, 0x81FA, 0x81FB, 0x81FE, 0x8201, 0x8202, 0x8205, 0x8207, + 0x820A, 0x820D, 0x8210, 0x8216, 0x8229, 0x822B, 0x8238, 0x8233, + 0x8240, 0x8259, 0x8258, 0x825D, 0x825A, 0x825F, 0x8264, 0x8262, + 0x8268, 0x826A, 0x826B, 0x822E, 0x8271, 0x8277, 0x8278, 0x827E, + 0x828D, 0x8292, 0x82AB, 0x829F, 0x82BB, 0x82AC, 0x82E1, 0x82E3, + 0x82DF, 0x82D2, 0x82F4, 0x82F3, 0x82FA, 0x8393, 0x8303, 0x82FB, + 0x82F9, 0x82DE, 0x8306, 0x82DC, 0x8309, 0x82D9 + }, + { /* category 72 */ + 0x8335, 0x8334, 0x8316, 0x8332, 0x8331, 0x8340, 0x8339, 0x8350, + 0x8345, 0x832F, 0x832B, 0x8317, 0x8318, 0x8385, 0x839A, 0x83AA, + 0x839F, 0x83A2, 0x8396, 0x8323, 0x838E, 0x8387, 0x838A, 0x837C, + 0x83B5, 0x8373, 0x8375, 0x83A0, 0x8389, 0x83A8, 0x83F4, 0x8413, + 0x83EB, 0x83CE, 0x83FD, 0x8403, 0x83D8, 0x840B, 0x83C1, 0x83F7, + 0x8407, 0x83E0, 0x83F2, 0x840D, 0x8422, 0x8420, 0x83BD, 0x8438, + 0x8506, 0x83FB, 0x846D, 0x842A, 0x843C, 0x855A, 0x8484, 0x8477, + 0x846B, 0x84AD, 0x846E, 0x8482, 0x8469, 0x8446, 0x842C, 0x846F, + 0x8479, 0x8435, 0x84CA, 0x8462, 0x84B9, 0x84BF, 0x849F, 0x84D9, + 0x84CD, 0x84BB, 0x84DA, 0x84D0, 0x84C1, 0x84C6, 0x84D6, 0x84A1, + 0x8521, 0x84FF, 0x84F4, 0x8517, 0x8518, 0x852C, 0x851F, 0x8515, + 0x8514, 0x84FC, 0x8540, 0x8563, 0x8558, 0x8548 + }, + { /* category 73 */ + 0x8541, 0x8602, 0x854B, 0x8555, 0x8580, 0x85A4, 0x8588, 0x8591, + 0x858A, 0x85A8, 0x856D, 0x8594, 0x859B, 0x85EA, 0x8587, 0x859C, + 0x8577, 0x857E, 0x8590, 0x85C9, 0x85BA, 0x85CF, 0x85B9, 0x85D0, + 0x85D5, 0x85DD, 0x85E5, 0x85DC, 0x85F9, 0x860A, 0x8613, 0x860B, + 0x85FE, 0x85FA, 0x8606, 0x8622, 0x861A, 0x8630, 0x863F, 0x864D, + 0x4E55, 0x8654, 0x865F, 0x8667, 0x8671, 0x8693, 0x86A3, 0x86A9, + 0x86AA, 0x868B, 0x868C, 0x86B6, 0x86AF, 0x86C4, 0x86C6, 0x86B0, + 0x86C9, 0x8823, 0x86AB, 0x86D4, 0x86DE, 0x86E9, 0x86EC, 0x86DF, + 0x86DB, 0x86EF, 0x8712, 0x8706, 0x8708, 0x8700, 0x8703, 0x86FB, + 0x8711, 0x8709, 0x870D, 0x86F9, 0x870A, 0x8734, 0x873F, 0x8737, + 0x873B, 0x8725, 0x8729, 0x871A, 0x8760, 0x875F, 0x8778, 0x874C, + 0x874E, 0x8774, 0x8757, 0x8768, 0x876E, 0x8759 + }, + { /* category 74 */ + 0x8753, 0x8763, 0x876A, 0x8805, 0x87A2, 0x879F, 0x8782, 0x87AF, + 0x87CB, 0x87BD, 0x87C0, 0x87D0, 0x96D6, 0x87AB, 0x87C4, 0x87B3, + 0x87C7, 0x87C6, 0x87BB, 0x87EF, 0x87F2, 0x87E0, 0x880F, 0x880D, + 0x87FE, 0x87F6, 0x87F7, 0x880E, 0x87D2, 0x8811, 0x8816, 0x8815, + 0x8822, 0x8821, 0x8831, 0x8836, 0x8839, 0x8827, 0x883B, 0x8844, + 0x8842, 0x8852, 0x8859, 0x885E, 0x8862, 0x886B, 0x8881, 0x887E, + 0x889E, 0x8875, 0x887D, 0x88B5, 0x8872, 0x8882, 0x8897, 0x8892, + 0x88AE, 0x8899, 0x88A2, 0x888D, 0x88A4, 0x88B0, 0x88BF, 0x88B1, + 0x88C3, 0x88C4, 0x88D4, 0x88D8, 0x88D9, 0x88DD, 0x88F9, 0x8902, + 0x88FC, 0x88F4, 0x88E8, 0x88F2, 0x8904, 0x890C, 0x890A, 0x8913, + 0x8943, 0x891E, 0x8925, 0x892A, 0x892B, 0x8941, 0x8944, 0x893B, + 0x8936, 0x8938, 0x894C, 0x891D, 0x8960, 0x895E + }, + { /* category 75 */ + 0x8966, 0x8964, 0x896D, 0x896A, 0x896F, 0x8974, 0x8977, 0x897E, + 0x8983, 0x8988, 0x898A, 0x8993, 0x8998, 0x89A1, 0x89A9, 0x89A6, + 0x89AC, 0x89AF, 0x89B2, 0x89BA, 0x89BD, 0x89BF, 0x89C0, 0x89DA, + 0x89DC, 0x89DD, 0x89E7, 0x89F4, 0x89F8, 0x8A03, 0x8A16, 0x8A10, + 0x8A0C, 0x8A1B, 0x8A1D, 0x8A25, 0x8A36, 0x8A41, 0x8A5B, 0x8A52, + 0x8A46, 0x8A48, 0x8A7C, 0x8A6D, 0x8A6C, 0x8A62, 0x8A85, 0x8A82, + 0x8A84, 0x8AA8, 0x8AA1, 0x8A91, 0x8AA5, 0x8AA6, 0x8A9A, 0x8AA3, + 0x8AC4, 0x8ACD, 0x8AC2, 0x8ADA, 0x8AEB, 0x8AF3, 0x8AE7, 0x8AE4, + 0x8AF1, 0x8B14, 0x8AE0, 0x8AE2, 0x8AF7, 0x8ADE, 0x8ADB, 0x8B0C, + 0x8B07, 0x8B1A, 0x8AE1, 0x8B16, 0x8B10, 0x8B17, 0x8B20, 0x8B33, + 0x97AB, 0x8B26, 0x8B2B, 0x8B3E, 0x8B28, 0x8B41, 0x8B4C, 0x8B4F, + 0x8B4E, 0x8B49, 0x8B56, 0x8B5B, 0x8B5A, 0x8B6B + }, + { /* category 76 */ + 0x8B5F, 0x8B6C, 0x8B6F, 0x8B74, 0x8B7D, 0x8B80, 0x8B8C, 0x8B8E, + 0x8B92, 0x8B93, 0x8B96, 0x8B99, 0x8B9A, 0x8C3A, 0x8C41, 0x8C3F, + 0x8C48, 0x8C4C, 0x8C4E, 0x8C50, 0x8C55, 0x8C62, 0x8C6C, 0x8C78, + 0x8C7A, 0x8C82, 0x8C89, 0x8C85, 0x8C8A, 0x8C8D, 0x8C8E, 0x8C94, + 0x8C7C, 0x8C98, 0x621D, 0x8CAD, 0x8CAA, 0x8CBD, 0x8CB2, 0x8CB3, + 0x8CAE, 0x8CB6, 0x8CC8, 0x8CC1, 0x8CE4, 0x8CE3, 0x8CDA, 0x8CFD, + 0x8CFA, 0x8CFB, 0x8D04, 0x8D05, 0x8D0A, 0x8D07, 0x8D0F, 0x8D0D, + 0x8D10, 0x9F4E, 0x8D13, 0x8CCD, 0x8D14, 0x8D16, 0x8D67, 0x8D6D, + 0x8D71, 0x8D73, 0x8D81, 0x8D99, 0x8DC2, 0x8DBE, 0x8DBA, 0x8DCF, + 0x8DDA, 0x8DD6, 0x8DCC, 0x8DDB, 0x8DCB, 0x8DEA, 0x8DEB, 0x8DDF, + 0x8DE3, 0x8DFC, 0x8E08, 0x8E09, 0x8DFF, 0x8E1D, 0x8E1E, 0x8E10, + 0x8E1F, 0x8E42, 0x8E35, 0x8E30, 0x8E34, 0x8E4A + }, + { /* category 77 */ + 0x8E47, 0x8E49, 0x8E4C, 0x8E50, 0x8E48, 0x8E59, 0x8E64, 0x8E60, + 0x8E2A, 0x8E63, 0x8E55, 0x8E76, 0x8E72, 0x8E7C, 0x8E81, 0x8E87, + 0x8E85, 0x8E84, 0x8E8B, 0x8E8A, 0x8E93, 0x8E91, 0x8E94, 0x8E99, + 0x8EAA, 0x8EA1, 0x8EAC, 0x8EB0, 0x8EC6, 0x8EB1, 0x8EBE, 0x8EC5, + 0x8EC8, 0x8ECB, 0x8EDB, 0x8EE3, 0x8EFC, 0x8EFB, 0x8EEB, 0x8EFE, + 0x8F0A, 0x8F05, 0x8F15, 0x8F12, 0x8F19, 0x8F13, 0x8F1C, 0x8F1F, + 0x8F1B, 0x8F0C, 0x8F26, 0x8F33, 0x8F3B, 0x8F39, 0x8F45, 0x8F42, + 0x8F3E, 0x8F4C, 0x8F49, 0x8F46, 0x8F4E, 0x8F57, 0x8F5C, 0x8F62, + 0x8F63, 0x8F64, 0x8F9C, 0x8F9F, 0x8FA3, 0x8FAD, 0x8FAF, 0x8FB7, + 0x8FDA, 0x8FE5, 0x8FE2, 0x8FEA, 0x8FEF, 0x9087, 0x8FF4, 0x9005, + 0x8FF9, 0x8FFA, 0x9011, 0x9015, 0x9021, 0x900D, 0x901E, 0x9016, + 0x900B, 0x9027, 0x9036, 0x9035, 0x9039, 0x8FF8 + }, + { /* category 78 */ + 0x904F, 0x9050, 0x9051, 0x9052, 0x900E, 0x9049, 0x903E, 0x9056, + 0x9058, 0x905E, 0x9068, 0x906F, 0x9076, 0x96A8, 0x9072, 0x9082, + 0x907D, 0x9081, 0x9080, 0x908A, 0x9089, 0x908F, 0x90A8, 0x90AF, + 0x90B1, 0x90B5, 0x90E2, 0x90E4, 0x6248, 0x90DB, 0x9102, 0x9112, + 0x9119, 0x9132, 0x9130, 0x914A, 0x9156, 0x9158, 0x9163, 0x9165, + 0x9169, 0x9173, 0x9172, 0x918B, 0x9189, 0x9182, 0x91A2, 0x91AB, + 0x91AF, 0x91AA, 0x91B5, 0x91B4, 0x91BA, 0x91C0, 0x91C1, 0x91C9, + 0x91CB, 0x91D0, 0x91D6, 0x91DF, 0x91E1, 0x91DB, 0x91FC, 0x91F5, + 0x91F6, 0x921E, 0x91FF, 0x9214, 0x922C, 0x9215, 0x9211, 0x925E, + 0x9257, 0x9245, 0x9249, 0x9264, 0x9248, 0x9295, 0x923F, 0x924B, + 0x9250, 0x929C, 0x9296, 0x9293, 0x929B, 0x925A, 0x92CF, 0x92B9, + 0x92B7, 0x92E9, 0x930F, 0x92FA, 0x9344, 0x932E + }, + { /* category 79 */ + 0x9319, 0x9322, 0x931A, 0x9323, 0x933A, 0x9335, 0x933B, 0x935C, + 0x9360, 0x937C, 0x936E, 0x9356, 0x93B0, 0x93AC, 0x93AD, 0x9394, + 0x93B9, 0x93D6, 0x93D7, 0x93E8, 0x93E5, 0x93D8, 0x93C3, 0x93DD, + 0x93D0, 0x93C8, 0x93E4, 0x941A, 0x9414, 0x9413, 0x9403, 0x9407, + 0x9410, 0x9436, 0x942B, 0x9435, 0x9421, 0x943A, 0x9441, 0x9452, + 0x9444, 0x945B, 0x9460, 0x9462, 0x945E, 0x946A, 0x9229, 0x9470, + 0x9475, 0x9477, 0x947D, 0x945A, 0x947C, 0x947E, 0x9481, 0x947F, + 0x9582, 0x9587, 0x958A, 0x9594, 0x9596, 0x9598, 0x9599, 0x95A0, + 0x95A8, 0x95A7, 0x95AD, 0x95BC, 0x95BB, 0x95B9, 0x95BE, 0x95CA, + 0x6FF6, 0x95C3, 0x95CD, 0x95CC, 0x95D5, 0x95D4, 0x95D6, 0x95DC, + 0x95E1, 0x95E5, 0x95E2, 0x9621, 0x9628, 0x962E, 0x962F, 0x9642, + 0x964C, 0x964F, 0x964B, 0x9677, 0x965C, 0x965E + }, + { /* category 80 */ + 0x965D, 0x965F, 0x9666, 0x9672, 0x966C, 0x968D, 0x9698, 0x9695, + 0x9697, 0x96AA, 0x96A7, 0x96B1, 0x96B2, 0x96B0, 0x96B4, 0x96B6, + 0x96B8, 0x96B9, 0x96CE, 0x96CB, 0x96C9, 0x96CD, 0x894D, 0x96DC, + 0x970D, 0x96D5, 0x96F9, 0x9704, 0x9706, 0x9708, 0x9713, 0x970E, + 0x9711, 0x970F, 0x9716, 0x9719, 0x9724, 0x972A, 0x9730, 0x9739, + 0x973D, 0x973E, 0x9744, 0x9746, 0x9748, 0x9742, 0x9749, 0x975C, + 0x9760, 0x9764, 0x9766, 0x9768, 0x52D2, 0x976B, 0x9771, 0x9779, + 0x9785, 0x977C, 0x9781, 0x977A, 0x9786, 0x978B, 0x978F, 0x9790, + 0x979C, 0x97A8, 0x97A6, 0x97A3, 0x97B3, 0x97B4, 0x97C3, 0x97C6, + 0x97C8, 0x97CB, 0x97DC, 0x97ED, 0x9F4F, 0x97F2, 0x7ADF, 0x97F6, + 0x97F5, 0x980F, 0x980C, 0x9838, 0x9824, 0x9821, 0x9837, 0x983D, + 0x9846, 0x984F, 0x984B, 0x986B, 0x986F, 0x9870 + }, + { /* category 81 */ + 0x9871, 0x9874, 0x9873, 0x98AA, 0x98AF, 0x98B1, 0x98B6, 0x98C4, + 0x98C3, 0x98C6, 0x98E9, 0x98EB, 0x9903, 0x9909, 0x9912, 0x9914, + 0x9918, 0x9921, 0x991D, 0x991E, 0x9924, 0x9920, 0x992C, 0x992E, + 0x993D, 0x993E, 0x9942, 0x9949, 0x9945, 0x9950, 0x994B, 0x9951, + 0x9952, 0x994C, 0x9955, 0x9997, 0x9998, 0x99A5, 0x99AD, 0x99AE, + 0x99BC, 0x99DF, 0x99DB, 0x99DD, 0x99D8, 0x99D1, 0x99ED, 0x99EE, + 0x99F1, 0x99F2, 0x99FB, 0x99F8, 0x9A01, 0x9A0F, 0x9A05, 0x99E2, + 0x9A19, 0x9A2B, 0x9A37, 0x9A45, 0x9A42, 0x9A40, 0x9A43, 0x9A3E, + 0x9A55, 0x9A4D, 0x9A5B, 0x9A57, 0x9A5F, 0x9A62, 0x9A65, 0x9A64, + 0x9A69, 0x9A6B, 0x9A6A, 0x9AAD, 0x9AB0, 0x9ABC, 0x9AC0, 0x9ACF, + 0x9AD1, 0x9AD3, 0x9AD4, 0x9ADE, 0x9ADF, 0x9AE2, 0x9AE3, 0x9AE6, + 0x9AEF, 0x9AEB, 0x9AEE, 0x9AF4, 0x9AF1, 0x9AF7 + }, + { /* category 82 */ + 0x9AFB, 0x9B06, 0x9B18, 0x9B1A, 0x9B1F, 0x9B22, 0x9B23, 0x9B25, + 0x9B27, 0x9B28, 0x9B29, 0x9B2A, 0x9B2E, 0x9B2F, 0x9B32, 0x9B44, + 0x9B43, 0x9B4F, 0x9B4D, 0x9B4E, 0x9B51, 0x9B58, 0x9B74, 0x9B93, + 0x9B83, 0x9B91, 0x9B96, 0x9B97, 0x9B9F, 0x9BA0, 0x9BA8, 0x9BB4, + 0x9BC0, 0x9BCA, 0x9BB9, 0x9BC6, 0x9BCF, 0x9BD1, 0x9BD2, 0x9BE3, + 0x9BE2, 0x9BE4, 0x9BD4, 0x9BE1, 0x9C3A, 0x9BF2, 0x9BF1, 0x9BF0, + 0x9C15, 0x9C14, 0x9C09, 0x9C13, 0x9C0C, 0x9C06, 0x9C08, 0x9C12, + 0x9C0A, 0x9C04, 0x9C2E, 0x9C1B, 0x9C25, 0x9C24, 0x9C21, 0x9C30, + 0x9C47, 0x9C32, 0x9C46, 0x9C3E, 0x9C5A, 0x9C60, 0x9C67, 0x9C76, + 0x9C78, 0x9CE7, 0x9CEC, 0x9CF0, 0x9D09, 0x9D08, 0x9CEB, 0x9D03, + 0x9D06, 0x9D2A, 0x9D26, 0x9DAF, 0x9D23, 0x9D1F, 0x9D44, 0x9D15, + 0x9D12, 0x9D41, 0x9D3F, 0x9D3E, 0x9D46, 0x9D48 + }, + { /* category 83 */ + 0x9D5D, 0x9D5E, 0x9D64, 0x9D51, 0x9D50, 0x9D59, 0x9D72, 0x9D89, + 0x9D87, 0x9DAB, 0x9D6F, 0x9D7A, 0x9D9A, 0x9DA4, 0x9DA9, 0x9DB2, + 0x9DC4, 0x9DC1, 0x9DBB, 0x9DB8, 0x9DBA, 0x9DC6, 0x9DCF, 0x9DC2, + 0x9DD9, 0x9DD3, 0x9DF8, 0x9DE6, 0x9DED, 0x9DEF, 0x9DFD, 0x9E1A, + 0x9E1B, 0x9E1E, 0x9E75, 0x9E79, 0x9E7D, 0x9E81, 0x9E88, 0x9E8B, + 0x9E8C, 0x9E92, 0x9E95, 0x9E91, 0x9E9D, 0x9EA5, 0x9EA9, 0x9EB8, + 0x9EAA, 0x9EAD, 0x9761, 0x9ECC, 0x9ECE, 0x9ECF, 0x9ED0, 0x9ED4, + 0x9EDC, 0x9EDE, 0x9EDD, 0x9EE0, 0x9EE5, 0x9EE8, 0x9EEF, 0x9EF4, + 0x9EF6, 0x9EF7, 0x9EF9, 0x9EFB, 0x9EFC, 0x9EFD, 0x9F07, 0x9F08, + 0x76B7, 0x9F15, 0x9F21, 0x9F2C, 0x9F3E, 0x9F4A, 0x9F52, 0x9F54, + 0x9F63, 0x9F5F, 0x9F60, 0x9F61, 0x9F66, 0x9F67, 0x9F6C, 0x9F6A, + 0x9F77, 0x9F72, 0x9F76, 0x9F95, 0x9F9C, 0x9FA0 + }, + { /* category 84 */ + 0x582F, 0x69C7, 0x9059, 0x7464, 0x51DC, 0x7199, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 85 */ + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 86 */ + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 87 */ + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 88 */ + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 + }, + { /* category 89 */ + 0x7E8A, 0x891C, 0x9348, 0x9288, 0x84DC, 0x4FC9, 0x70BB, 0x6631, + 0x68C8, 0x92F9, 0x66FB, 0x5F45, 0x4E28, 0x4EE1, 0x4EFC, 0x4F00, + 0x4F03, 0x4F39, 0x4F56, 0x4F92, 0x4F8A, 0x4F9A, 0x4F94, 0x4FCD, + 0x5040, 0x5022, 0x4FFF, 0x501E, 0x5046, 0x5070, 0x5042, 0x5094, + 0x50F4, 0x50D8, 0x514A, 0x5164, 0x519D, 0x51BE, 0x51EC, 0x5215, + 0x529C, 0x52A6, 0x52C0, 0x52DB, 0x5300, 0x5307, 0x5324, 0x5372, + 0x5393, 0x53B2, 0x53DD, 0xFA0E, 0x549C, 0x548A, 0x54A9, 0x54FF, + 0x5586, 0x5759, 0x5765, 0x57AC, 0x57C8, 0x57C7, 0xFA0F, 0xFA10, + 0x589E, 0x58B2, 0x590B, 0x5953, 0x595B, 0x595D, 0x5963, 0x59A4, + 0x59BA, 0x5B56, 0x5BC0, 0x752F, 0x5BD8, 0x5BEC, 0x5C1E, 0x5CA6, + 0x5CBA, 0x5CF5, 0x5D27, 0x5D53, 0xFA11, 0x5D42, 0x5D6D, 0x5DB8, + 0x5DB9, 0x5DD0, 0x5F21, 0x5F34, 0x5F67, 0x5FB7 + }, + { /* category 90 */ + 0x5FDE, 0x605D, 0x6085, 0x608A, 0x60DE, 0x60D5, 0x6120, 0x60F2, + 0x6111, 0x6137, 0x6130, 0x6198, 0x6213, 0x62A6, 0x63F5, 0x6460, + 0x649D, 0x64CE, 0x654E, 0x6600, 0x6615, 0x663B, 0x6609, 0x662E, + 0x661E, 0x6624, 0x6665, 0x6657, 0x6659, 0xFA12, 0x6673, 0x6699, + 0x66A0, 0x66B2, 0x66BF, 0x66FA, 0x670E, 0xF929, 0x6766, 0x67BB, + 0x6852, 0x67C0, 0x6801, 0x6844, 0x68CF, 0xFA13, 0x6968, 0xFA14, + 0x6998, 0x69E2, 0x6A30, 0x6A6B, 0x6A46, 0x6A73, 0x6A7E, 0x6AE2, + 0x6AE4, 0x6BD6, 0x6C3F, 0x6C5C, 0x6C86, 0x6C6F, 0x6CDA, 0x6D04, + 0x6D87, 0x6D6F, 0x6D96, 0x6DAC, 0x6DCF, 0x6DF8, 0x6DF2, 0x6DFC, + 0x6E39, 0x6E5C, 0x6E27, 0x6E3C, 0x6EBF, 0x6F88, 0x6FB5, 0x6FF5, + 0x7005, 0x7007, 0x7028, 0x7085, 0x70AB, 0x710F, 0x7104, 0x715C, + 0x7146, 0x7147, 0xFA15, 0x71C1, 0x71FE, 0x72B1 + }, + { /* category 91 */ + 0x72BE, 0x7324, 0xFA16, 0x7377, 0x73BD, 0x73C9, 0x73D6, 0x73E3, + 0x73D2, 0x7407, 0x73F5, 0x7426, 0x742A, 0x7429, 0x742E, 0x7462, + 0x7489, 0x749F, 0x7501, 0x756F, 0x7682, 0x769C, 0x769E, 0x769B, + 0x76A6, 0xFA17, 0x7746, 0x52AF, 0x7821, 0x784E, 0x7864, 0x787A, + 0x7930, 0xFA18, 0xFA19, 0xFA1A, 0x7994, 0xFA1B, 0x799B, 0x7AD1, + 0x7AE7, 0xFA1C, 0x7AEB, 0x7B9E, 0xFA1D, 0x7D48, 0x7D5C, 0x7DB7, + 0x7DA0, 0x7DD6, 0x7E52, 0x7F47, 0x7FA1, 0xFA1E, 0x8301, 0x8362, + 0x837F, 0x83C7, 0x83F6, 0x8448, 0x84B4, 0x8553, 0x8559, 0x856B, + 0xFA1F, 0x85B0, 0xFA20, 0xFA21, 0x8807, 0x88F5, 0x8A12, 0x8A37, + 0x8A79, 0x8AA7, 0x8ABE, 0x8ADF, 0xFA22, 0x8AF6, 0x8B53, 0x8B7F, + 0x8CF0, 0x8CF4, 0x8D12, 0x8D76, 0xFA23, 0x8ECF, 0xFA24, 0xFA25, + 0x9067, 0x90DE, 0xFA26, 0x9115, 0x9127, 0x91DA + }, + { /* category 92 */ + 0x91D7, 0x91DE, 0x91ED, 0x91EE, 0x91E4, 0x91E5, 0x9206, 0x9210, + 0x920A, 0x923A, 0x9240, 0x923C, 0x924E, 0x9259, 0x9251, 0x9239, + 0x9267, 0x92A7, 0x9277, 0x9278, 0x92E7, 0x92D7, 0x92D9, 0x92D0, + 0xFA27, 0x92D5, 0x92E0, 0x92D3, 0x9325, 0x9321, 0x92FB, 0xFA28, + 0x931E, 0x92FF, 0x931D, 0x9302, 0x9370, 0x9357, 0x93A4, 0x93C6, + 0x93DE, 0x93F8, 0x9431, 0x9445, 0x9448, 0x9592, 0xF9DC, 0xFA29, + 0x969D, 0x96AF, 0x9733, 0x973B, 0x9743, 0x974D, 0x974F, 0x9751, + 0x9755, 0x9857, 0x9865, 0xFA2A, 0xFA2B, 0x9927, 0xFA2C, 0x999E, + 0x9A4E, 0x9AD9, 0x9ADC, 0x9B75, 0x9B72, 0x9B8F, 0x9BB1, 0x9BBB, + 0x9C00, 0x9D70, 0x9D6B, 0xFA2D, 0x9E19, 0x9ED1, 0x0000, 0x0000, + 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, + 0x2178, 0x2179, 0xFFE2, 0xFFE4, 0xFF07, 0xFF02 + } + }; + +#endif /* JISX0208_H */ + +#ifdef __cplusplus +} +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/msinttypes/inttypes.h b/Build/source/libs/gd/libgd-2.1.1/src/msinttypes/inttypes.h new file mode 100644 index 00000000000..4b3828a2162 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/msinttypes/inttypes.h @@ -0,0 +1,305 @@ +// ISO C9x compliant inttypes.h for Microsoft Visual Studio +// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 +// +// Copyright (c) 2006 Alexander Chemeris +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. The name of the author may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef _MSC_VER // [ +#error "Use this header only with Microsoft Visual C++ compilers!" +#endif // _MSC_VER ] + +#ifndef _MSC_INTTYPES_H_ // [ +#define _MSC_INTTYPES_H_ + +#if _MSC_VER > 1000 +#pragma once +#endif + +#include "stdint.h" + +// 7.8 Format conversion of integer types + +typedef struct { + intmax_t quot; + intmax_t rem; +} imaxdiv_t; + +// 7.8.1 Macros for format specifiers + +#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [ See footnote 185 at page 198 + +// The fprintf macros for signed integers are: +#define PRId8 "d" +#define PRIi8 "i" +#define PRIdLEAST8 "d" +#define PRIiLEAST8 "i" +#define PRIdFAST8 "d" +#define PRIiFAST8 "i" + +#define PRId16 "hd" +#define PRIi16 "hi" +#define PRIdLEAST16 "hd" +#define PRIiLEAST16 "hi" +#define PRIdFAST16 "hd" +#define PRIiFAST16 "hi" + +#define PRId32 "I32d" +#define PRIi32 "I32i" +#define PRIdLEAST32 "I32d" +#define PRIiLEAST32 "I32i" +#define PRIdFAST32 "I32d" +#define PRIiFAST32 "I32i" + +#define PRId64 "I64d" +#define PRIi64 "I64i" +#define PRIdLEAST64 "I64d" +#define PRIiLEAST64 "I64i" +#define PRIdFAST64 "I64d" +#define PRIiFAST64 "I64i" + +#define PRIdMAX "I64d" +#define PRIiMAX "I64i" + +#define PRIdPTR "Id" +#define PRIiPTR "Ii" + +// The fprintf macros for unsigned integers are: +#define PRIo8 "o" +#define PRIu8 "u" +#define PRIx8 "x" +#define PRIX8 "X" +#define PRIoLEAST8 "o" +#define PRIuLEAST8 "u" +#define PRIxLEAST8 "x" +#define PRIXLEAST8 "X" +#define PRIoFAST8 "o" +#define PRIuFAST8 "u" +#define PRIxFAST8 "x" +#define PRIXFAST8 "X" + +#define PRIo16 "ho" +#define PRIu16 "hu" +#define PRIx16 "hx" +#define PRIX16 "hX" +#define PRIoLEAST16 "ho" +#define PRIuLEAST16 "hu" +#define PRIxLEAST16 "hx" +#define PRIXLEAST16 "hX" +#define PRIoFAST16 "ho" +#define PRIuFAST16 "hu" +#define PRIxFAST16 "hx" +#define PRIXFAST16 "hX" + +#define PRIo32 "I32o" +#define PRIu32 "I32u" +#define PRIx32 "I32x" +#define PRIX32 "I32X" +#define PRIoLEAST32 "I32o" +#define PRIuLEAST32 "I32u" +#define PRIxLEAST32 "I32x" +#define PRIXLEAST32 "I32X" +#define PRIoFAST32 "I32o" +#define PRIuFAST32 "I32u" +#define PRIxFAST32 "I32x" +#define PRIXFAST32 "I32X" + +#define PRIo64 "I64o" +#define PRIu64 "I64u" +#define PRIx64 "I64x" +#define PRIX64 "I64X" +#define PRIoLEAST64 "I64o" +#define PRIuLEAST64 "I64u" +#define PRIxLEAST64 "I64x" +#define PRIXLEAST64 "I64X" +#define PRIoFAST64 "I64o" +#define PRIuFAST64 "I64u" +#define PRIxFAST64 "I64x" +#define PRIXFAST64 "I64X" + +#define PRIoMAX "I64o" +#define PRIuMAX "I64u" +#define PRIxMAX "I64x" +#define PRIXMAX "I64X" + +#define PRIoPTR "Io" +#define PRIuPTR "Iu" +#define PRIxPTR "Ix" +#define PRIXPTR "IX" + +// The fscanf macros for signed integers are: +#define SCNd8 "d" +#define SCNi8 "i" +#define SCNdLEAST8 "d" +#define SCNiLEAST8 "i" +#define SCNdFAST8 "d" +#define SCNiFAST8 "i" + +#define SCNd16 "hd" +#define SCNi16 "hi" +#define SCNdLEAST16 "hd" +#define SCNiLEAST16 "hi" +#define SCNdFAST16 "hd" +#define SCNiFAST16 "hi" + +#define SCNd32 "ld" +#define SCNi32 "li" +#define SCNdLEAST32 "ld" +#define SCNiLEAST32 "li" +#define SCNdFAST32 "ld" +#define SCNiFAST32 "li" + +#define SCNd64 "I64d" +#define SCNi64 "I64i" +#define SCNdLEAST64 "I64d" +#define SCNiLEAST64 "I64i" +#define SCNdFAST64 "I64d" +#define SCNiFAST64 "I64i" + +#define SCNdMAX "I64d" +#define SCNiMAX "I64i" + +#ifdef _WIN64 // [ +# define SCNdPTR "I64d" +# define SCNiPTR "I64i" +#else // _WIN64 ][ +# define SCNdPTR "ld" +# define SCNiPTR "li" +#endif // _WIN64 ] + +// The fscanf macros for unsigned integers are: +#define SCNo8 "o" +#define SCNu8 "u" +#define SCNx8 "x" +#define SCNX8 "X" +#define SCNoLEAST8 "o" +#define SCNuLEAST8 "u" +#define SCNxLEAST8 "x" +#define SCNXLEAST8 "X" +#define SCNoFAST8 "o" +#define SCNuFAST8 "u" +#define SCNxFAST8 "x" +#define SCNXFAST8 "X" + +#define SCNo16 "ho" +#define SCNu16 "hu" +#define SCNx16 "hx" +#define SCNX16 "hX" +#define SCNoLEAST16 "ho" +#define SCNuLEAST16 "hu" +#define SCNxLEAST16 "hx" +#define SCNXLEAST16 "hX" +#define SCNoFAST16 "ho" +#define SCNuFAST16 "hu" +#define SCNxFAST16 "hx" +#define SCNXFAST16 "hX" + +#define SCNo32 "lo" +#define SCNu32 "lu" +#define SCNx32 "lx" +#define SCNX32 "lX" +#define SCNoLEAST32 "lo" +#define SCNuLEAST32 "lu" +#define SCNxLEAST32 "lx" +#define SCNXLEAST32 "lX" +#define SCNoFAST32 "lo" +#define SCNuFAST32 "lu" +#define SCNxFAST32 "lx" +#define SCNXFAST32 "lX" + +#define SCNo64 "I64o" +#define SCNu64 "I64u" +#define SCNx64 "I64x" +#define SCNX64 "I64X" +#define SCNoLEAST64 "I64o" +#define SCNuLEAST64 "I64u" +#define SCNxLEAST64 "I64x" +#define SCNXLEAST64 "I64X" +#define SCNoFAST64 "I64o" +#define SCNuFAST64 "I64u" +#define SCNxFAST64 "I64x" +#define SCNXFAST64 "I64X" + +#define SCNoMAX "I64o" +#define SCNuMAX "I64u" +#define SCNxMAX "I64x" +#define SCNXMAX "I64X" + +#ifdef _WIN64 // [ +# define SCNoPTR "I64o" +# define SCNuPTR "I64u" +# define SCNxPTR "I64x" +# define SCNXPTR "I64X" +#else // _WIN64 ][ +# define SCNoPTR "lo" +# define SCNuPTR "lu" +# define SCNxPTR "lx" +# define SCNXPTR "lX" +#endif // _WIN64 ] + +#endif // __STDC_FORMAT_MACROS ] + +// 7.8.2 Functions for greatest-width integer types + +// 7.8.2.1 The imaxabs function +#define imaxabs _abs64 + +// 7.8.2.2 The imaxdiv function + +// This is modified version of div() function from Microsoft's div.c found +// in %MSVC.NET%\crt\src\div.c +#ifdef STATIC_IMAXDIV // [ +static +#else // STATIC_IMAXDIV ][ +_inline +#endif // STATIC_IMAXDIV ] +imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom) +{ + imaxdiv_t result; + + result.quot = numer / denom; + result.rem = numer % denom; + + if (numer < 0 && result.rem > 0) { + // did division wrong; must fix up + ++result.quot; + result.rem -= denom; + } + + return result; +} + +// 7.8.2.3 The strtoimax and strtoumax functions +#define strtoimax _strtoi64 +#define strtoumax _strtoui64 + +// 7.8.2.4 The wcstoimax and wcstoumax functions +#define wcstoimax _wcstoi64 +#define wcstoumax _wcstoui64 + + +#endif // _MSC_INTTYPES_H_ ] diff --git a/Build/source/libs/gd/libgd-2.1.1/src/msinttypes/stdint.h b/Build/source/libs/gd/libgd-2.1.1/src/msinttypes/stdint.h new file mode 100644 index 00000000000..d02608a5972 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/msinttypes/stdint.h @@ -0,0 +1,247 @@ +// ISO C9x compliant stdint.h for Microsoft Visual Studio +// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 +// +// Copyright (c) 2006-2008 Alexander Chemeris +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. The name of the author may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef _MSC_VER // [ +#error "Use this header only with Microsoft Visual C++ compilers!" +#endif // _MSC_VER ] + +#ifndef _MSC_STDINT_H_ // [ +#define _MSC_STDINT_H_ + +#if _MSC_VER > 1000 +#pragma once +#endif + +#include <limits.h> + +// For Visual Studio 6 in C++ mode and for many Visual Studio versions when +// compiling for ARM we should wrap <wchar.h> include with 'extern "C++" {}' +// or compiler give many errors like this: +// error C2733: second C linkage of overloaded function 'wmemchr' not allowed +#ifdef __cplusplus +extern "C" { +#endif +# include <wchar.h> +#ifdef __cplusplus +} +#endif + +// Define _W64 macros to mark types changing their size, like intptr_t. +#ifndef _W64 +# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300 +# define _W64 __w64 +# else +# define _W64 +# endif +#endif + + +// 7.18.1 Integer types + +// 7.18.1.1 Exact-width integer types + +// Visual Studio 6 and Embedded Visual C++ 4 doesn't +// realize that, e.g. char has the same size as __int8 +// so we give up on __intX for them. +#if (_MSC_VER < 1300) + typedef signed char int8_t; + typedef signed short int16_t; + typedef signed int int32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; +#else + typedef signed __int8 int8_t; + typedef signed __int16 int16_t; + typedef signed __int32 int32_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; +#endif +typedef signed __int64 int64_t; +typedef unsigned __int64 uint64_t; + + +// 7.18.1.2 Minimum-width integer types +typedef int8_t int_least8_t; +typedef int16_t int_least16_t; +typedef int32_t int_least32_t; +typedef int64_t int_least64_t; +typedef uint8_t uint_least8_t; +typedef uint16_t uint_least16_t; +typedef uint32_t uint_least32_t; +typedef uint64_t uint_least64_t; + +// 7.18.1.3 Fastest minimum-width integer types +typedef int8_t int_fast8_t; +typedef int16_t int_fast16_t; +typedef int32_t int_fast32_t; +typedef int64_t int_fast64_t; +typedef uint8_t uint_fast8_t; +typedef uint16_t uint_fast16_t; +typedef uint32_t uint_fast32_t; +typedef uint64_t uint_fast64_t; + +// 7.18.1.4 Integer types capable of holding object pointers +#ifdef _WIN64 // [ + typedef signed __int64 intptr_t; + typedef unsigned __int64 uintptr_t; +#else // _WIN64 ][ + typedef _W64 signed int intptr_t; + typedef _W64 unsigned int uintptr_t; +#endif // _WIN64 ] + +// 7.18.1.5 Greatest-width integer types +typedef int64_t intmax_t; +typedef uint64_t uintmax_t; + + +// 7.18.2 Limits of specified-width integer types + +#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259 + +// 7.18.2.1 Limits of exact-width integer types +#define INT8_MIN ((int8_t)_I8_MIN) +#define INT8_MAX _I8_MAX +#define INT16_MIN ((int16_t)_I16_MIN) +#define INT16_MAX _I16_MAX +#define INT32_MIN ((int32_t)_I32_MIN) +#define INT32_MAX _I32_MAX +#define INT64_MIN ((int64_t)_I64_MIN) +#define INT64_MAX _I64_MAX +#define UINT8_MAX _UI8_MAX +#define UINT16_MAX _UI16_MAX +#define UINT32_MAX _UI32_MAX +#define UINT64_MAX _UI64_MAX + +// 7.18.2.2 Limits of minimum-width integer types +#define INT_LEAST8_MIN INT8_MIN +#define INT_LEAST8_MAX INT8_MAX +#define INT_LEAST16_MIN INT16_MIN +#define INT_LEAST16_MAX INT16_MAX +#define INT_LEAST32_MIN INT32_MIN +#define INT_LEAST32_MAX INT32_MAX +#define INT_LEAST64_MIN INT64_MIN +#define INT_LEAST64_MAX INT64_MAX +#define UINT_LEAST8_MAX UINT8_MAX +#define UINT_LEAST16_MAX UINT16_MAX +#define UINT_LEAST32_MAX UINT32_MAX +#define UINT_LEAST64_MAX UINT64_MAX + +// 7.18.2.3 Limits of fastest minimum-width integer types +#define INT_FAST8_MIN INT8_MIN +#define INT_FAST8_MAX INT8_MAX +#define INT_FAST16_MIN INT16_MIN +#define INT_FAST16_MAX INT16_MAX +#define INT_FAST32_MIN INT32_MIN +#define INT_FAST32_MAX INT32_MAX +#define INT_FAST64_MIN INT64_MIN +#define INT_FAST64_MAX INT64_MAX +#define UINT_FAST8_MAX UINT8_MAX +#define UINT_FAST16_MAX UINT16_MAX +#define UINT_FAST32_MAX UINT32_MAX +#define UINT_FAST64_MAX UINT64_MAX + +// 7.18.2.4 Limits of integer types capable of holding object pointers +#ifdef _WIN64 // [ +# define INTPTR_MIN INT64_MIN +# define INTPTR_MAX INT64_MAX +# define UINTPTR_MAX UINT64_MAX +#else // _WIN64 ][ +# define INTPTR_MIN INT32_MIN +# define INTPTR_MAX INT32_MAX +# define UINTPTR_MAX UINT32_MAX +#endif // _WIN64 ] + +// 7.18.2.5 Limits of greatest-width integer types +#define INTMAX_MIN INT64_MIN +#define INTMAX_MAX INT64_MAX +#define UINTMAX_MAX UINT64_MAX + +// 7.18.3 Limits of other integer types + +#ifdef _WIN64 // [ +# define PTRDIFF_MIN _I64_MIN +# define PTRDIFF_MAX _I64_MAX +#else // _WIN64 ][ +# define PTRDIFF_MIN _I32_MIN +# define PTRDIFF_MAX _I32_MAX +#endif // _WIN64 ] + +#define SIG_ATOMIC_MIN INT_MIN +#define SIG_ATOMIC_MAX INT_MAX + +#ifndef SIZE_MAX // [ +# ifdef _WIN64 // [ +# define SIZE_MAX _UI64_MAX +# else // _WIN64 ][ +# define SIZE_MAX _UI32_MAX +# endif // _WIN64 ] +#endif // SIZE_MAX ] + +// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h> +#ifndef WCHAR_MIN // [ +# define WCHAR_MIN 0 +#endif // WCHAR_MIN ] +#ifndef WCHAR_MAX // [ +# define WCHAR_MAX _UI16_MAX +#endif // WCHAR_MAX ] + +#define WINT_MIN 0 +#define WINT_MAX _UI16_MAX + +#endif // __STDC_LIMIT_MACROS ] + + +// 7.18.4 Limits of other integer types + +#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260 + +// 7.18.4.1 Macros for minimum-width integer constants + +#define INT8_C(val) val##i8 +#define INT16_C(val) val##i16 +#define INT32_C(val) val##i32 +#define INT64_C(val) val##i64 + +#define UINT8_C(val) val##ui8 +#define UINT16_C(val) val##ui16 +#define UINT32_C(val) val##ui32 +#define UINT64_C(val) val##ui64 + +// 7.18.4.2 Macros for greatest-width integer constants +#define INTMAX_C INT64_C +#define UINTMAX_C UINT64_C + +#endif // __STDC_CONSTANT_MACROS ] + + +#endif // _MSC_STDINT_H_ ] diff --git a/Build/source/libs/gd/libgd-2.1.1/src/pngtogd.c b/Build/source/libs/gd/libgd-2.1.1/src/pngtogd.c new file mode 100644 index 00000000000..f00fe8f7ac9 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/pngtogd.c @@ -0,0 +1,49 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include "gd.h" + +/* A short program which converts a .png file into a .gd file, for + your convenience in creating images on the fly from a + basis image that must be loaded quickly. The .gd format + is not intended to be a general-purpose format. */ + +int +main (int argc, char **argv) +{ + gdImagePtr im = NULL; + FILE *in, *out; + if (argc != 3) { + fprintf (stderr, "Usage: pngtogd filename.png filename.gd\n"); + exit (1); + } + in = fopen (argv[1], "rb"); + if (!in) { + fprintf (stderr, "Input file does not exist!\n"); + exit (1); + } +#ifdef HAVE_LIBPNG + im = gdImageCreateFromPng (in); +#else + fprintf (stderr, "No PNG library support available.\n"); +#endif + fclose (in); + if (!im) { + fprintf (stderr, "Input is not in PNG format!\n"); + exit (1); + } + out = fopen (argv[2], "wb"); + if (!out) { + fprintf (stderr, "Output file cannot be written to!\n"); + gdImageDestroy (im); + exit (1); + } + gdImageGd (im, out); + fclose (out); + gdImageDestroy (im); + + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/pngtogd2.c b/Build/source/libs/gd/libgd-2.1.1/src/pngtogd2.c new file mode 100644 index 00000000000..e474afb6612 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/pngtogd2.c @@ -0,0 +1,57 @@ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include "gd.h" + +/* A short program which converts a .png file into a .gd2 file, for + your convenience in creating images on the fly from a + basis image that must be loaded quickly. The .gd2 format + is not intended to be a general-purpose format. */ + +int +main (int argc, char **argv) +{ + gdImagePtr im; + FILE *in, *out; + int cs, fmt; + + if (argc != 5) { + fprintf(stderr, "Usage: pngtogd2 filename.png filename.gd2 cs fmt\n"); + fprintf(stderr, " where cs is the chunk size\n"); + fprintf(stderr, " fmt is 1 for raw, 2 for compressed\n"); + exit (1); + } + in = fopen (argv[1], "rb"); + if (!in) { + fprintf(stderr, "Input file does not exist!\n"); + exit (1); + } +#ifdef HAVE_LIBPNG + im = gdImageCreateFromPng (in); +#else + im = NULL; + fprintf(stderr, "No PNG library support available.\n"); +#endif + fclose (in); + if (!im) { + fprintf(stderr, "Input is not in PNG format!\n"); + exit (1); + } + out = fopen (argv[2], "wb"); + if (!out) { + fprintf(stderr, "Output file cannot be written to!\n"); + gdImageDestroy (im); + exit (1); + } + cs = atoi (argv[3]); + fmt = atoi (argv[4]); + gdImageGd2 (im, out, cs, fmt); + fclose (out); + gdImageDestroy (im); + + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/testac.c b/Build/source/libs/gd/libgd-2.1.1/src/testac.c new file mode 100644 index 00000000000..0d200f0630c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/testac.c @@ -0,0 +1,127 @@ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include "gd.h" + +/* If palette is true, we convert from truecolor to palette at the end, + to test gdImageTrueColorToPalette and see file size/ + quality tradeoffs. */ + +void testDrawing (gdImagePtr im_in, + double scale, int blending, int palette, char *filename); + +int +main (int argc, char *argv[]) +{ +#ifdef HAVE_LIBPNG + /* Input and output files */ + FILE *in; + + /* Input image */ + gdImagePtr im_in = 0; + + if (argc != 2) { + fprintf (stderr, "Usage: testac filename.png\n"); + exit (1); + } + /* Load original PNG, which should contain alpha channel + information. We will use it in two ways: preserving it + literally, for use with compatible browsers, and + compositing it ourselves against a background of our + choosing (alpha blending). We'll change its size + and try creating palette versions of it. */ + in = fopen (argv[1], "rb"); + if (!in) { + fprintf (stderr, "Can't load %s.\n", argv[1]); + exit (1); + } else { + im_in = gdImageCreateFromPng (in); + fclose (in); + } + testDrawing (im_in, 1.0, 0, 0, "noblending-fullsize-truecolor.png"); + testDrawing (im_in, 1.0, 1, 0, "blending-fullsize-truecolor.png"); + testDrawing (im_in, 0.5, 0, 0, "noblending-halfsize-truecolor.png"); + testDrawing (im_in, 0.5, 1, 0, "blending-halfsize-truecolor.png"); + testDrawing (im_in, 2.0, 0, 0, "noblending-doublesize-truecolor.png"); + testDrawing (im_in, 2.0, 1, 0, "blending-doublesize-truecolor.png"); + testDrawing (im_in, 1.0, 0, 1, "noblending-fullsize-palette.png"); + testDrawing (im_in, 1.0, 1, 1, "blending-fullsize-palette.png"); + testDrawing (im_in, 0.5, 0, 1, "noblending-halfsize-palette.png"); + testDrawing (im_in, 0.5, 1, 1, "blending-halfsize-palette.png"); + testDrawing (im_in, 2.0, 0, 1, "noblending-doublesize-palette.png"); + testDrawing (im_in, 2.0, 1, 1, "blending-doublesize-palette.png"); + gdImageDestroy (im_in); +#else + fprintf (stderr, "No PNG library support.\n"); +#endif + + return 0; +} + +/* If palette is true, we convert from truecolor to palette at the end, + to test gdImageTrueColorToPalette and see file size/ + quality tradeoffs. */ +void +testDrawing (gdImagePtr im_in, + double scale, int blending, int palette, char *filename) +{ + gdImagePtr im_out; + FILE *out; + /* Create output image. */ + im_out = gdImageCreateTrueColor ((int) (gdImageSX (im_in) * scale), + (int) (gdImageSY (im_in) * scale)); + /* + Request alpha blending. This causes future + drawing operations to perform alpha channel blending + with the background, resulting in an opaque image. + Without this call, pixels in the foreground color are + copied literally, *including* the alpha channel value, + resulting in an output image which is potentially + not opaque. This flag can be set and cleared as often + as desired. */ + gdImageAlphaBlending (im_out, blending); + + /* Flood with light blue. */ + gdImageFill (im_out, (int) (gdImageSX (im_in) * scale / 2), + (int) (gdImageSY (im_in) * scale / 2), + gdTrueColor (192, 192, 255)); + /* Copy the source image. Alpha blending should result in + compositing against red. With blending turned off, the + browser or viewer will composite against its preferred + background, or, if it does not support an alpha channel, + we will see the original colors for the pixels that + ought to be transparent or semitransparent. */ + gdImageCopyResampled (im_out, im_in, + 0, 0, + 0, 0, + (int) (gdImageSX (im_in) * scale), + (int) (gdImageSY (im_in) * scale), gdImageSX (im_in), + gdImageSY (im_in)); + /* Write PNG */ + out = fopen (filename, "wb"); + + /* If this image is the result of alpha channel blending, + it will not contain an interesting alpha channel itself. + Save a little file size by not saving the alpha channel. + Otherwise the file would typically be slightly larger. */ + gdImageSaveAlpha (im_out, !blending); + + /* If requested, convert from truecolor to palette. */ + if (palette) { + /* Dithering, 256 colors. */ + gdImageTrueColorToPalette (im_out, 1, 256); + } + +#ifdef HAVE_LIBPNG + gdImagePng (im_out, out); +#else + fprintf (stderr, "No PNG library support.\n"); +#endif + fclose (out); + + gdImageDestroy (im_out); +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/testtr.c b/Build/source/libs/gd/libgd-2.1.1/src/testtr.c new file mode 100644 index 00000000000..b7b419f96c0 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/testtr.c @@ -0,0 +1,53 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif /* HAVE_CONFIG_H */ + +#include <stdio.h> +#include "gd.h" + +#define FALSE 0 +#define TRUE (!FALSE) + +int +main(void) +{ +#ifdef HAVE_LIBFREETYPE + FILE *out; + int transparent, green, black; + gdImagePtr im; + + im = gdImageCreateTrueColor(100,100); + + black = gdImageColorResolveAlpha(im, 0, 0, 0, gdAlphaOpaque); + green = gdImageColorResolveAlpha(im, 0, gdGreenMax, 0, gdAlphaOpaque); + transparent = gdImageColorResolveAlpha(im, + gdRedMax-1, gdGreenMax, gdBlueMax, gdAlphaTransparent); + gdImageColorTransparent(im, transparent); + + /* Blending must be off to lay a transparent basecolor. + Nothing to blend with anyway. */ + gdImageAlphaBlending(im, FALSE); + gdImageFill (im, im->sx/2, im->sy/2, transparent); + /* Blend everything else together, + especially fonts over non-transparent backgrounds */ + gdImageAlphaBlending(im, TRUE); + + gdImageFilledRectangle (im, 30, 30, 70, 70, green); + gdImageStringFT (im, NULL, black, "Times", 18, 0, 50, 50, "Hello"); + + gdImageSaveAlpha (im, TRUE); +#ifdef HAVE_LIBPNG + out = fopen ("testtr.png", "wb"); + gdImagePng (im, out); + fclose (out); +#else + fprintf(stderr, "Compiled without libpng support\n"); +#endif /* HAVE_LIBPNG */ + gdImageDestroy (im); + + return 0; +#else + fprintf(stderr, "Compiled without freetype support\n"); + return 0; +#endif /* HAVE_LIBFREETYPE */ +} diff --git a/Build/source/libs/gd/libgd-2.1.1/src/wbmp.c b/Build/source/libs/gd/libgd-2.1.1/src/wbmp.c new file mode 100644 index 00000000000..6be39410c55 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/wbmp.c @@ -0,0 +1,334 @@ +/* WBMP + * ---- + * WBMP Level 0: B/W, Uncompressed + * This implements the WBMP format as specified in WAPSpec 1.1 and 1.2. + * It does not support ExtHeaders as defined in the spec. The spec states + * that a WAP client does not need to implement ExtHeaders. + * + * (c) 2000 Johan Van den Brande <johan@vandenbrande.com> + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <stdio.h> +#include <stddef.h> +#include <stdlib.h> +#include <string.h> + +#include "wbmp.h" +#include "gd.h" +#include "gdhelpers.h" + +#ifdef NOTDEF +# define __TEST /* Compile with main function */ +# define __DEBUG /* Extra verbose when with __TEST */ +# define __WRITE /* readwbmp and writewbmp(stdout) */ +# define __VIEW /* view the wbmp on stdout */ +#endif + +/* getmbi + * ------ + * Get a multibyte integer from a generic getin function + * 'getin' can be getc, with in = NULL + * you can find getin as a function just above the main function + * This way you gain a lot of flexibilty about how this package + * reads a wbmp file. + */ +int getmbi(int (*getin) (void *in), void *in) +{ + int i, mbi = 0; + + do { + i = getin(in); + if(i < 0) { + return (-1); + } + mbi = (mbi << 7) | (i & 0x7f); + } while(i & 0x80); + + return mbi; +} + +/* putmbi + * ------ + * Put a multibyte intgerer in some kind of output stream + * I work here with a function pointer, to make it as generic + * as possible. Look at this function as an iterator on the + * mbi integers it spits out. + * + */ +void putmbi(int i, void (*putout)(int c, void *out), void *out) +{ + int cnt, l, accu; + + /* Get number of septets */ + accu = cnt = 0; + while(accu != i) { + accu += i & 0x7f << 7 * cnt++; + } + + /* Produce the multibyte output */ + for(l = cnt - 1; l > 0; l--) { + putout(0x80 | (i & 0x7f << 7 * l) >> 7 * l, out); + } + + putout(i & 0x7f, out); +} + +/* skipheader + * ---------- + * Skips the ExtHeader. Not needed for the moment + */ +int skipheader(int (*getin)(void *in), void *in) +{ + int i; + + do { + i = getin(in); + if(i < 0) { + return (-1); + } + } while(i & 0x80); + + return 0; +} + +/* create wbmp + * ----------- + * create an empty wbmp + */ +Wbmp *createwbmp(int width, int height, int color) +{ + int i; + Wbmp *wbmp; + + if((wbmp = (Wbmp *)gdMalloc(sizeof (Wbmp))) == NULL) { + return (NULL); + } + + if(overflow2(sizeof(int), width)) { + gdFree(wbmp); + return NULL; + } + + if(overflow2(sizeof(int) * width, height)) { + gdFree(wbmp); + return NULL; + } + + if((wbmp->bitmap = (int *)gdMalloc(sizeof(int) * width * height)) == NULL) { + gdFree(wbmp); + return NULL; + } + + wbmp->width = width; + wbmp->height = height; + + for(i = 0; i < width * height; wbmp->bitmap[i++] = color); + + return wbmp; +} + +/* readwbmp + * ------- + * Actually reads the WBMP format from an open file descriptor + * It goes along by returning a pointer to a WBMP struct. + */ +int readwbmp(int (*getin) (void *in), void *in, Wbmp **return_wbmp) +{ + int row, col, byte, pel, pos; + Wbmp *wbmp; + + if((wbmp = (Wbmp *)gdMalloc(sizeof(Wbmp))) == NULL) { + return -1; + } + + wbmp->type = getin(in); + if(wbmp->type != 0) { + gdFree(wbmp); + return -1; + } + + if(skipheader(getin, in)) { + gdFree(wbmp); + return -1; + } + + wbmp->width = getmbi(getin, in); + if(wbmp->width == -1) { + gdFree(wbmp); + return -1; + } + + wbmp->height = getmbi(getin, in); + if(wbmp->height == -1) { + gdFree(wbmp); + return -1; + } + +#ifdef __DEBUG + printf("W: %d, H: %d\n", wbmp->width, wbmp->height); +#endif + + if( overflow2(sizeof(int), wbmp->width) || + overflow2(sizeof(int) * wbmp->width, wbmp->height)) { + gdFree(wbmp); + return -1; + } + + if((wbmp->bitmap = (int *)gdMalloc(sizeof(int) * wbmp->width * wbmp->height)) == NULL) { + gdFree(wbmp); + return -1; + } + +#ifdef __DEBUG + printf("DATA CONSTRUCTED\n"); +#endif + + pos = 0; + for(row = 0; row < wbmp->height; row++) { + for(col = 0; col < wbmp->width;) { + byte = getin(in); + + for(pel = 7; pel >= 0; pel--) { + if(col++ < wbmp->width) { + if(byte & 1 << pel) { + wbmp->bitmap[pos] = WBMP_WHITE; + } else { + wbmp->bitmap[pos] = WBMP_BLACK; + } + pos++; + } + } + } + } + + *return_wbmp = wbmp; + + return 0; +} + +/* writewbmp + * --------- + * Write a wbmp to a file descriptor + * + * Why not just giving a filedescriptor to this function? + * Well, the incentive to write this function was the complete + * integration in gd library from www.libgd.org. They use + * their own io functions, so the passing of a function seemed to be + * a logic(?) decision ... + */ +int writewbmp(Wbmp *wbmp, void (*putout)(int c, void *out), void *out) +{ + int row, col; + int bitpos, octet; + + /* Generate the header */ + putout(0, out); /* WBMP Type 0: B/W, Uncompressed bitmap */ + putout(0, out); /* FixHeaderField */ + + /* Size of the image */ + putmbi(wbmp->width, putout, out); /* width */ + putmbi(wbmp->height, putout, out); /* height */ + + + /* Image data */ + for(row = 0; row < wbmp->height; row++) { + bitpos = 8; + octet = 0; + + for(col = 0; col < wbmp->width; col++) { + octet |= ((wbmp->bitmap[row * wbmp->width + col] == 1) ? WBMP_WHITE : WBMP_BLACK) << --bitpos; + if(bitpos == 0) { + bitpos = 8; + putout(octet, out); + octet = 0; + } + } + + if(bitpos != 8) { + putout(octet, out); + } + } + + return 0; +} + +/* freewbmp + * -------- + * gdFrees up memory occupied by a WBMP structure + */ +void freewbmp(Wbmp *wbmp) +{ + gdFree(wbmp->bitmap); + gdFree(wbmp); +} + +/* printwbmp + * --------- + * print a WBMP to stdout for visualisation + */ +void printwbmp(Wbmp *wbmp) +{ + int row, col; + + for(row = 0; row < wbmp->height; row++) { + for(col = 0; col < wbmp->width; col++) { + if(wbmp->bitmap[wbmp->width * row + col] == WBMP_BLACK) { + putchar('#'); + } else { + putchar(' '); + } + } + putchar('\n'); + } +} + +#ifdef __TEST + +/* putout to file descriptor + * ------------------------- + */ +int putout(int c, void *out) +{ + return (putc(c, (FILE *)out)); +} + +/* getin from file descriptor + * -------------------------- + */ +int getin(void *in) +{ + return (getc((FILE *)in)); +} + +/* Main function + * ------------- + */ +int main(int argc, char *argv[]) +{ + FILE *wbmp_file; + Wbmp *wbmp; + + wbmp_file = fopen(argv[1], "rb"); + if(wbmp_file) { + readwbmp(&getin, wbmp_file, &wbmp); +#ifdef __VIEW +#ifdef __DEBUG + printf("\nVIEWING IMAGE\n"); +#endif + printwbmp(wbmp); +#endif +#ifdef __WRITE +#ifdef __DEBUG + printf("\nDUMPING WBMP to STDOUT\n"); +#endif + writewbmp(wbmp, &putout, stdout); +#endif + freewbmp(wbmp); + fclose(wbmp_file); + } +} +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/wbmp.h b/Build/source/libs/gd/libgd-2.1.1/src/wbmp.h new file mode 100644 index 00000000000..f163b4be410 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/wbmp.h @@ -0,0 +1,51 @@ +#ifdef __cplusplus +extern "C" { +#endif + + /* WBMP + * ---- + * WBMP Level 0: B/W, Uncompressed + * This implements the WBMP format as specified in WAPSpec 1.1 and 1.2. + * It does not support ExtHeaders as defined in the spec. The spec states + * that a WAP client does not need to implement ExtHeaders. + * + * (c) 2000 Johan Van den Brande <johan@vandenbrande.com> + * + * Header file + */ +#ifndef __WBMP_H +#define __WBMP_H 1 + + /* WBMP struct + * ----------- + * A Wireless bitmap structure + */ + + typedef struct Wbmp_ { + int type; /* type of the wbmp */ + int width; /* width of the image */ + int height; /* height of the image */ + int *bitmap;/* pointer to data: 0 = WHITE , 1 = BLACK */ + } + Wbmp; + +#define WBMP_WHITE 1 +#define WBMP_BLACK 0 + + /* Proto's + * ------- + */ + void putmbi(int i, void (*putout)(int c, void *out), void *out); + int getmbi(int (*getin)(void *in), void *in); + int skipheader(int (*getin)(void *in), void *in); + Wbmp *createwbmp(int width, int height, int color); + int readwbmp(int (*getin)(void *in), void *in, Wbmp **wbmp); + int writewbmp(Wbmp *wbmp, void (*putout)(int c, void *out), void *out); + void freewbmp(Wbmp *wbmp); + void printwbmp(Wbmp *wbmp); + +#endif + +#ifdef __cplusplus +} +#endif diff --git a/Build/source/libs/gd/libgd-2.1.1/src/webpimg.c b/Build/source/libs/gd/libgd-2.1.1/src/webpimg.c new file mode 100644 index 00000000000..cf73d642b65 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/webpimg.c @@ -0,0 +1,905 @@ +/*===========================================================================* + - Copyright 2010 Google Inc. + - + - This code is licensed under the same terms as WebM: + - Software License Agreement: http://www.webmproject.org/license/software/ + - Additional IP Rights Grant: http://www.webmproject.org/license/additional/ + *===========================================================================*/ + +/* + * Encoding/Decoding of WebP still image compression format. + * + * 1. WebPDecode: Takes an array of bytes (string) corresponding to the WebP + * encoded image and generates output in the YUV format with + * the color components U, V subsampled to 1/2 resolution along + * each dimension. + * + * 2. YUV420toRGBA: Converts from YUV (with color subsampling) such as produced + * by the WebPDecode routine into 32 bits per pixel RGBA data + * array. This data array can be directly used by the Leptonica + * Pix in-memory image format. + * + * 3. WebPEncode: Takes a Y, U, V data buffers (with color components U and V + * subsampled to 1/2 resolution) and generates the WebP string + * + * 4. RGBAToYUV420: Generates Y, U, V data (with color subsampling) from 32 bits + * per pixel RGBA data buffer. The resulting YUV data can be + * directly fed into the WebPEncode routine. + * + * 5. AdjustColorspace: + * + * 6. AdjustColorspaceBack: + */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gd.h" +#include "gd_errors.h" +#ifdef HAVE_LIBVPX +#include "webpimg.h" + +#include <math.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/stat.h> + +#include "vpx/vpx_decoder.h" +#include "vpx/vp8dx.h" +#include "vpx/vpx_encoder.h" +#include "vpx/vp8cx.h" +#include "gd.h" + +/*---------------------------------------------------------------------* + * color conversions * + *---------------------------------------------------------------------*/ + +#ifndef inline +# define inline __inline +#endif +static inline int clip(float v, int a, int b) { + return (v > b) ? b : (v < 0) ? 0 : (int)(v); +} +enum { + COLOR_RED = 0, + COLOR_GREEN = 1, + COLOR_BLUE = 2, + ALPHA_CHANNEL = 3 +}; + +/* endian neutral extractions of RGBA from a 32 bit pixel */ +static const uint32 RED_SHIFT = + 8 * (sizeof(uint32) - 1 - COLOR_RED); /* 24 */ +static const uint32 GREEN_SHIFT = + 8 * (sizeof(uint32) - 1 - COLOR_GREEN); /* 16 */ +static const uint32 BLUE_SHIFT = + 8 * (sizeof(uint32) - 1 - COLOR_BLUE); /* 8 */ +static const uint32 ALPHA_SHIFT = + 8 * (sizeof(uint32) - 1 - ALPHA_CHANNEL); /* 0 */ + +static inline int GetRed(const uint32* rgba) { + return gdTrueColorGetRed(*rgba); +} + +static inline int GetGreen(const uint32* rgba) { + return gdTrueColorGetGreen(*rgba); +} + +static inline int GetBlue(const uint32* rgba) { + return gdTrueColorGetBlue(*rgba); +} + +enum { YUV_FRAC = 16 }; + +static inline int clip_uv(int v) { + v = (v + (257 << (YUV_FRAC + 2 - 1))) >> (YUV_FRAC + 2); + return ((v & ~0xff) == 0) ? v : v < 0 ? 0u : 255u; +} + + +/* YUV <-----> RGB conversions */ +/* The exact naming is Y'CbCr, following the ITU-R BT.601 standard. + * More information at: http://en.wikipedia.org/wiki/YCbCr + */ +static inline int GetLumaY(int r, int g, int b) { + const int kRound = (1 << (YUV_FRAC - 1)) + (16 << YUV_FRAC); + // Y = 0.2569 * R + 0.5044 * G + 0.0979 * B + 16 + const int luma = 16839 * r + 33059 * g + 6420 * b; + return (luma + kRound) >> YUV_FRAC; +} + +static inline int GetLumaYfromPtr(uint32* rgba) { + const int r = GetRed(rgba); + const int g = GetGreen(rgba); + const int b = GetBlue(rgba); + return GetLumaY(r, g, b); +} + +static inline int GetChromaU(int r, int g, int b) { + // U = -0.1483 * R - 0.2911 * G + 0.4394 * B + 128 + return clip_uv(-9719 * r - 19081 * g + 28800 * b); +} + +static inline int GetChromaV(int r, int g, int b) { + // V = 0.4394 * R - 0.3679 * G - 0.0715 * B + 128 + return clip_uv(+28800 * r - 24116 * g - 4684 * b); +} + +/* Converts YUV to RGB and writes into a 32 bit pixel in endian + * neutral fashion + */ +enum { RGB_FRAC = 16, RGB_HALF = (1 << RGB_FRAC) / 2, + RGB_RANGE_MIN = -227, RGB_RANGE_MAX = 256 + 226 }; + +static int init_done = 0; +static int16_t kVToR[256], kUToB[256]; +static int32_t kVToG[256], kUToG[256]; +static uint8_t kClip[RGB_RANGE_MAX - RGB_RANGE_MIN]; + +static void InitTables() { + int i; + for (i = 0; i < 256; ++i) { + kVToR[i] = (89858 * (i - 128) + RGB_HALF) >> RGB_FRAC; + kUToG[i] = -22014 * (i - 128) + RGB_HALF; + kVToG[i] = -45773 * (i - 128); + kUToB[i] = (113618 * (i - 128) + RGB_HALF) >> RGB_FRAC; + } + for (i = RGB_RANGE_MIN; i < RGB_RANGE_MAX; ++i) { + const int j = ((i - 16) * 76283 + RGB_HALF) >> RGB_FRAC; + kClip[i - RGB_RANGE_MIN] = (j < 0) ? 0 : (j > 255) ? 255 : j; + } + + init_done = 1; +} + +static void ToRGB(int y, int u, int v, uint32* const dst) { + const int r_off = kVToR[v]; + const int g_off = (kVToG[v] + kUToG[u]) >> RGB_FRAC; + const int b_off = kUToB[u]; + const int r = kClip[y + r_off - RGB_RANGE_MIN]; + const int g = kClip[y + g_off - RGB_RANGE_MIN]; + const int b = kClip[y + b_off - RGB_RANGE_MIN]; + *dst = (r << RED_SHIFT) | (g << GREEN_SHIFT) | (b << BLUE_SHIFT); +} + +static inline uint32 get_le32(const uint8* const data) { + return data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24); +} + +/* Returns the difference (in dB) between two images represented in YUV format + * + * Input: + * Y1/U1/V1: The Y/U/V data of the first image + * Y2/U2/V2: The Y/U/V data of the second image + * + * Returns the PSNR (http://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio) + * value computed bewteen the two images + */ +double GetPSNRYuv(const uint8* Y1, + const uint8* U1, + const uint8* V1, + const uint8* Y2, + const uint8* U2, + const uint8* V2, + int y_width, + int y_height) { + int x, y, row_idx; + const int uv_width = ((y_width + 1) >> 1); + const int uv_height = ((y_height + 1) >> 1); + double sse = 0., count = 0.; + for (y = 0; y < y_height; ++y) { + count += y_width; + row_idx = y * y_width; + for (x = 0; x < y_width; ++x) { + double diff = Y1[row_idx + x] - Y2[row_idx + x]; + sse += diff * diff; + } + } + for (y = 0; y < uv_height; ++y) { + count += 2 * uv_width; + row_idx = y * uv_width; + for (x = 0; x < uv_width; ++x) { + const double diff_U = U1[row_idx + x] - U2[row_idx + x]; + const double diff_V = V1[row_idx + x] - V2[row_idx + x]; + sse += diff_U * diff_U + diff_V * diff_V; + } + } + return -4.3429448 * log(sse / (255. * 255. * count)); +} + +/* Returns the difference (in dB) between two images. One represented + * using Y,U,V vectors and the other is webp image data. + * Input: + * Y1/U1/V1: The Y/U/V data of the first image + * imgdata: data buffer containing webp image + * imgdata_size: size of the imgdata buffer + * + * Returns the PSNR value computed bewteen the two images + */ +double WebPGetPSNR(const uint8* Y1, + const uint8* U1, + const uint8* V1, + uint8* imgdata, + int imgdata_size) { + uint8* Y2 = NULL; + uint8* U2 = NULL; + uint8* V2 = NULL; + int w = 0, h = 0; + double psnr = 0; + + WebPDecode(imgdata, + imgdata_size, + &Y2, + &U2, + &V2, + &w, + &h); + + psnr = GetPSNRYuv(Y1, U1, V1, Y2, U2, V2, w, h); + free(Y2); + + return psnr; +} + +/*---------------------------------------------------------------------* + * Reading WebP * + *---------------------------------------------------------------------*/ + +/* RIFF layout is: + * 0ffset tag + * 0...3 "RIFF" 4-byte tag + * 4...7 size of image data (including metadata) starting at offset 8 + * 8...11 "WEBP" our form-type signature + * 12..15 "VP8 " 4-byte tags, describing the raw video format used + * 16..19 size of the raw WebP image data, starting at offset 20 + * 20.... the WebP bytes + * There can be extra chunks after the "VP8 " chunk (ICMT, ICOP, ...) + * All 32-bits sizes are in little-endian order. + * Note: chunk data must be padded to multiple of 2 in size + */ + +int SkipRiffHeader(const uint8** data_ptr, int *data_size_ptr) { + /* 20 bytes RIFF header 10 bytes VP8 header */ + const int kHeaderSize = (20 + 10); + uint32 chunk_size = 0xffffffffu; + + if (*data_size_ptr >= kHeaderSize && !memcmp(*data_ptr, "RIFF", 4)) { + if (memcmp(*data_ptr + 8, "WEBP", 4)) { + return 0; /* wrong image file signature */ + } else { + const uint32 riff_size = get_le32(*data_ptr + 4); + if (memcmp(*data_ptr + 12, "VP8 ", 4)) { + return 0; /* invalid compression format */ + } + chunk_size = get_le32(*data_ptr + 16); + if ((chunk_size > riff_size + 8) || (chunk_size & 1)) { + return 0; /* inconsistent size information. */ + } + /* We have a RIFF container. Skip it. */ + *data_ptr += 20; + *data_size_ptr -= 20; + } + } + return chunk_size; +} + +/* Generate RGBA row from an YUV row (with width upsampling of chrome data) + * Input: + * 1, 2, 3. y_src, u_src, v_src - Pointers to input Y, U, V row data + * respectively. We reuse these variables, they iterate over all pixels in + * the row. + * 4. y_width: width of the Y image plane (aka image width) + * Output: + * 5. rgb_dst: pointer to the output rgb row. We reuse this variable, it + * iterates over all pixels in the row. + */ +static void YUV420toRGBLine(uint8* y_src, + uint8* u_src, + uint8* v_src, + int y_width, + uint32* rgb_dst) { + int x; + for (x = 0; x < (y_width >> 1); ++x) { + const int U = u_src[0]; + const int V = v_src[0]; + ToRGB(y_src[0], U, V, rgb_dst); + ToRGB(y_src[1], U, V, rgb_dst + 1); + ++u_src; + ++v_src; + y_src += 2; + rgb_dst += 2; + } + if (y_width & 1) { /* Rightmost pixel */ + ToRGB(y_src[0], (*u_src), (*v_src), rgb_dst); + } +} + +/* Converts from YUV (with color subsampling) such as produced by the WebPDecode + * routine into 32 bits per pixel RGBA data array. This data array can be + * directly used by the Leptonica Pix in-memory image format. + * Input: + * 1, 2, 3. Y, U, V: the input data buffers + * 4. pixwpl: the desired words per line corresponding to the supplied + * output pixdata. + * 5. width, height: the dimensions of the image whose data resides in Y, + * U, V. + * Output: + * 6. pixdata: the output data buffer. Caller should allocate + * height * pixwpl bytes of memory before calling this routine. + */ +void YUV420toRGBA(uint8* Y, + uint8* U, + uint8* V, + int words_per_line, + int width, + int height, + uint32* pixdata) { + int y_width = width; + int y_stride = y_width; + int uv_width = ((y_width + 1) >> 1); + int uv_stride = uv_width; + int y; + + if (!init_done) + InitTables(); + + /* note that the U, V upsampling in height is happening here as the U, V + * buffers sent to successive odd-even pair of lines is same. + */ + for (y = 0; y < height; ++y) { + YUV420toRGBLine(Y + y * y_stride, + U + (y >> 1) * uv_stride, + V + (y >> 1) * uv_stride, + width, + pixdata + y * words_per_line); + } +} + +void gd_YUV420toRGBA(uint8* Y, + uint8* U, + uint8* V, + gdImagePtr im) { + int width = im->sx; + int height = im->sy; + int y_width = width; + int y_stride = y_width; + int uv_width = ((y_width + 1) >> 1); + int uv_stride = uv_width; + int y; + + /* output im must be truecolor */ + if (!im->trueColor) { + return; + } + + if (!init_done) + InitTables(); + + /* note that the U, V upsampling in height is happening here as the U, V + * buffers sent to successive odd-even pair of lines is same. + */ + for (y = 0; y < height; ++y) { + YUV420toRGBLine(Y + y * y_stride, + U + (y >> 1) * uv_stride, + V + (y >> 1) * uv_stride, + width, + (uint32 *)im->tpixels[y]); + } +} + +static WebPResult VPXDecode(const uint8* data, + int data_size, + uint8** p_Y, + uint8** p_U, + uint8** p_V, + int* p_width, + int* p_height) { + vpx_codec_ctx_t dec; + vp8_postproc_cfg_t ppcfg; + WebPResult result = webp_failure; + + if (!data || data_size <= 10 || !p_Y || !p_U || !p_V + || *p_Y != NULL || *p_U != NULL || *p_V != NULL) { + return webp_failure; + } + + if (vpx_codec_dec_init(&dec, + &vpx_codec_vp8_dx_algo, NULL, 0) != VPX_CODEC_OK) { + return webp_failure; + } + + ppcfg.post_proc_flag = VP8_NOFILTERING; + vpx_codec_control(&dec, VP8_SET_POSTPROC, &ppcfg); + + + if (vpx_codec_decode(&dec, data, data_size, NULL, 0) == VPX_CODEC_OK) { + vpx_codec_iter_t iter = NULL; + vpx_image_t* const img = vpx_codec_get_frame(&dec, &iter); + if (img) { + int y_width = img->d_w; + int y_height = img->d_h; + int y_stride = y_width; + int uv_width = (y_width + 1) >> 1; + int uv_stride = uv_width; + int uv_height = ((y_height + 1) >> 1); + int y; + + *p_width = y_width; + *p_height = y_height; + if ((*p_Y = (uint8 *)(calloc(y_stride * y_height + + 2 * uv_stride * uv_height, + sizeof(uint8)))) != NULL) { + *p_U = *p_Y + y_height * y_stride; + *p_V = *p_U + uv_height * uv_stride; + for (y = 0; y < y_height; ++y) { + memcpy(*p_Y + y * y_stride, + img->planes[0] + y * img->stride[0], + y_width); + } + for (y = 0; y < uv_height; ++y) { + memcpy(*p_U + y * uv_stride, + img->planes[1] + y * img->stride[1], + uv_width); + memcpy(*p_V + y * uv_stride, + img->planes[2] + y * img->stride[2], + uv_width); + } + result = webp_success; + } + } + } + vpx_codec_destroy(&dec); + + return result; +} + +WebPResult WebPDecode(const uint8* data, + int data_size, + uint8** p_Y, + uint8** p_U, + uint8** p_V, + int* p_width, + int* p_height) { + + const uint32 chunk_size = SkipRiffHeader(&data, &data_size); + if (!chunk_size) { + return webp_failure; /* unsupported RIFF header */ + } + + return VPXDecode(data, data_size, p_Y, p_U, p_V, p_width, p_height); +} + +/*---------------------------------------------------------------------* + * Writing WebP * + *---------------------------------------------------------------------*/ + +/* Takes a pair of RGBA row data as input and generates 2 rows of Y data and one + * row of subsampled U, V data as output + * Input: + * 1, 2. rgb_line1, rgb_line2 - input rgba rows + * 3. width - image width + * Outout: + * 4, 5, 6: Output Y, U, V row + */ +static void RGBALinepairToYUV420(uint32* rgb_line1, + uint32* rgb_line2, + int width, + uint8* Y_dst1, + uint8* Y_dst2, + uint8* u_dst, + uint8* v_dst) { + int x; + for (x = (width >> 1); x > 0; --x) { + const int sum_r = + GetRed(rgb_line1 + 0) + GetRed(rgb_line1 + 1) + + GetRed(rgb_line2 + 0) + GetRed(rgb_line2 + 1); + const int sum_g = + GetGreen(rgb_line1 + 0) + GetGreen(rgb_line1 + 1) + + GetGreen(rgb_line2 + 0) + GetGreen(rgb_line2 + 1); + const int sum_b = + GetBlue(rgb_line1 + 0) + GetBlue(rgb_line1 + 1) + + GetBlue(rgb_line2 + 0) + GetBlue(rgb_line2 + 1); + + Y_dst1[0] = GetLumaYfromPtr(rgb_line1 + 0); + Y_dst1[1] = GetLumaYfromPtr(rgb_line1 + 1); + Y_dst2[0] = GetLumaYfromPtr(rgb_line2 + 0); + Y_dst2[1] = GetLumaYfromPtr(rgb_line2 + 1); + + *u_dst++ = GetChromaU(sum_r, sum_g, sum_b); + *v_dst++ = GetChromaV(sum_r, sum_g, sum_b); + + rgb_line1 += 2; + rgb_line2 += 2; + Y_dst1 += 2; + Y_dst2 += 2; + } + + if (width & 1) { /* rightmost pixel. */ + const int sum_r = GetRed(rgb_line1) + GetRed(rgb_line2); + const int sum_g = GetGreen(rgb_line1) + GetGreen(rgb_line2); + const int sum_b = GetBlue(rgb_line1) + GetBlue(rgb_line2); + + Y_dst1[0] = GetLumaYfromPtr(rgb_line1); + Y_dst2[0] = GetLumaYfromPtr(rgb_line2); + *u_dst = GetChromaU(2 * sum_r, 2 * sum_g, 2 * sum_b); + *v_dst = GetChromaV(2 * sum_r, 2 * sum_g, 2 * sum_b); + } +} + +/* Generates Y, U, V data (with color subsampling) from 32 bits + * per pixel RGBA data buffer. The resulting YUV data can be directly fed into + * the WebPEncode routine. + * Input: + * 1. pixdatainput rgba data buffer + * 2. words per line corresponding to pixdata + * 3, 4. image width and height respectively + * Output: + * 5, 6, 7. Output YUV data buffers + */ +void gd_RGBAToYUV420(gdImagePtr im2, + uint8* Y, + uint8* U, + uint8* V) { + int y_width = im2->sx; + int y_height = im2->sy; + int y_stride = y_width; + int uv_width = ((y_width + 1) >> 1); + int uv_stride = uv_width; + int y; + gdImagePtr im = NULL; + int free_im = 0; + + if (!im2->trueColor) { + /* Todo: Replace the color/YUV functions with our own and simplify + that should boost the conversion a bit as well, not only for + palette image. */ + im = gdImageCreateTrueColor(im2->sx, im2->sy); + if (!im) { + gd_error("gd-webp error: cannot convert palette input to truecolor"); + return; + } + gdImageCopy(im, im2, 0, 0, 0, 0, im->sx, im->sy); + free_im = 1; + } else { + im = im2; + } + for (y = 0; y < (y_height >> 1); ++y) { + RGBALinepairToYUV420((uint32 *)im->tpixels[2 * y], + (uint32 *)im->tpixels[2 * y + 1], + y_width, + Y + 2 * y * y_stride, + Y + (2 * y + 1) * y_stride, + U + y * uv_stride, + V + y * uv_stride); + } + if (y_height & 1) { + RGBALinepairToYUV420((uint32 *)im->tpixels[y_height - 1], + (uint32 *)im->tpixels[y_height - 1], + y_width, + Y + (y_height - 1) * y_stride, + Y + (y_height - 1) * y_stride, + U + (y_height >> 1) * uv_stride, + V + (y_height >> 1) * uv_stride); + } + if (free_im) { + gdImageDestroy(im); + } +} + +/* Generates Y, U, V data (with color subsampling) from 32 bits + * per pixel RGBA data buffer. The resulting YUV data can be directly fed into + * the WebPEncode routine. + * Input: + * 1. pixdatainput rgba data buffer + * 2. words per line corresponding to pixdata + * 3, 4. image width and height respectively + * Output: + * 5, 6, 7. Output YUV data buffers + */ +void RGBAToYUV420(uint32* pixdata, + int words_per_line, + int width, + int height, + uint8* Y, + uint8* U, + uint8* V) { + int y_width = width; + int y_height = height; + int y_stride = y_width; + int uv_width = ((y_width + 1) >> 1); + int uv_stride = uv_width; + int y; + + for (y = 0; y < (y_height >> 1); ++y) { + RGBALinepairToYUV420(pixdata + 2 * y * words_per_line, + pixdata + (2 * y + 1) * words_per_line, + y_width, + Y + 2 * y * y_stride, + Y + (2 * y + 1) * y_stride, + U + y * uv_stride, + V + y * uv_stride); + } + if (y_height & 1) { + RGBALinepairToYUV420(pixdata + (y_height - 1) * words_per_line, + pixdata + (y_height - 1) * words_per_line, + y_width, + Y + (y_height - 1) * y_stride, + Y + (y_height - 1) * y_stride, + U + (y_height >> 1) * uv_stride, + V + (y_height >> 1) * uv_stride); + } +} + +static int codec_ctl(vpx_codec_ctx_t *enc, + enum vp8e_enc_control_id id, + int value) { + const vpx_codec_err_t res = vpx_codec_control_(enc, id, value); + if (res != VPX_CODEC_OK) { + return webp_failure; + } + return webp_success; +} + +static void SetupParams(vpx_codec_enc_cfg_t* cfg, + int QP) { + cfg->g_threads = 2; + cfg->rc_min_quantizer = QP; + cfg->rc_max_quantizer = QP; + cfg->kf_mode = VPX_KF_FIXED; +} + +/* VPXEncode: Takes a Y, U, V data buffers (with color components U and V + * subsampled to 1/2 resolution) and generates the VPX string. + * Output VPX string is placed in the *p_out buffer. container_size + * indicates number of bytes to be left blank at the beginning of + * *p_out buffer to accommodate for a container header. + * + * Return: success/failure + */ +static WebPResult VPXEncode(const uint8* Y, + const uint8* U, + const uint8* V, + int y_width, + int y_height, + int y_stride, + int uv_width, + int uv_height, + int uv_stride, + int QP, + int container_size, + unsigned char** p_out, + int* p_out_size_bytes) { + vpx_codec_iface_t* iface = &vpx_codec_vp8_cx_algo; + vpx_codec_err_t res; + vpx_codec_enc_cfg_t cfg; + vpx_codec_ctx_t enc; + WebPResult result = webp_failure; + vpx_image_t img; + + *p_out = NULL; + *p_out_size_bytes = 0; + + + /* validate input parameters. */ + if (!p_out || !Y || !U || !V + || y_width <= 0 || y_height <= 0 || uv_width <= 0 || uv_height <= 0 + || y_stride < y_width || uv_stride < uv_width + || QP < 0 || QP > 63) { + return webp_failure; + } + + res = vpx_codec_enc_config_default(iface, &cfg, 0); + if (res != VPX_CODEC_OK) { + return webp_failure; + } + + SetupParams(&cfg, QP); + cfg.g_w = y_width; + cfg.g_h = y_height; + + res = vpx_codec_enc_init(&enc, iface, &cfg, 0); + + if (res == VPX_CODEC_OK) { + codec_ctl(&enc, VP8E_SET_CPUUSED, 3); + codec_ctl(&enc, VP8E_SET_NOISE_SENSITIVITY, 0); + codec_ctl(&enc, VP8E_SET_SHARPNESS, 0); + codec_ctl(&enc, VP8E_SET_ENABLEAUTOALTREF, 0); + codec_ctl(&enc, VP8E_SET_ARNR_MAXFRAMES, 0); + codec_ctl(&enc, VP8E_SET_ARNR_TYPE, 0); + codec_ctl(&enc, VP8E_SET_ARNR_STRENGTH, 0); + codec_ctl(&enc, VP8E_SET_STATIC_THRESHOLD, 0); + codec_ctl(&enc, VP8E_SET_TOKEN_PARTITIONS, 2); + + vpx_img_wrap(&img, IMG_FMT_I420, + y_width, y_height, 16, (uint8*)(Y)); + img.planes[PLANE_Y] = (uint8*)(Y); + img.planes[PLANE_U] = (uint8*)(U); + img.planes[PLANE_V] = (uint8*)(V); + img.stride[PLANE_Y] = y_stride; + img.stride[PLANE_U] = uv_stride; + img.stride[PLANE_V] = uv_stride; + + res = vpx_codec_encode(&enc, &img, 0, 1, 0, VPX_DL_BEST_QUALITY); + + if (res == VPX_CODEC_OK) { + vpx_codec_iter_t iter = NULL; + const vpx_codec_cx_pkt_t* pkt = vpx_codec_get_cx_data(&enc, &iter); + if (pkt != NULL) { + *p_out = (unsigned char*)(calloc(container_size + pkt->data.frame.sz, + 1)); + + memcpy(*p_out + container_size, + (const void*)(pkt->data.frame.buf), + pkt->data.frame.sz); + *p_out_size_bytes = container_size + pkt->data.frame.sz; + + result = webp_success; + } + } + } + + vpx_codec_destroy(&enc); + + return result; +} + +WebPResult WebPEncode(const uint8* Y, + const uint8* U, + const uint8* V, + int y_width, + int y_height, + int y_stride, + int uv_width, + int uv_height, + int uv_stride, + int QP, + unsigned char** p_out, + int* p_out_size_bytes, + double *psnr) { + + const int kRiffHeaderSize = 20; + + if (VPXEncode(Y, U, V, + y_width, y_height, y_stride, + uv_width, uv_height, uv_stride, + QP, kRiffHeaderSize, + p_out, p_out_size_bytes) != webp_success) { + return webp_failure; + } else { + /* Write RIFF header */ + const int img_size_bytes = *p_out_size_bytes - kRiffHeaderSize; + const int chunk_size = (img_size_bytes + 1) & ~1; /* make size even */ + const int riff_size = chunk_size + 12; + const uint8_t kRiffHeader[20] = { 'R', 'I', 'F', 'F', + (riff_size >> 0) & 255, + (riff_size >> 8) & 255, + (riff_size >> 16) & 255, + (riff_size >> 24) & 255, + 'W', 'E', 'B', 'P', + 'V', 'P', '8', ' ', + (chunk_size >> 0) & 255, + (chunk_size >> 8) & 255, + (chunk_size >> 16) & 255, + (chunk_size >> 24) & 255 }; + memcpy(*p_out, kRiffHeader, kRiffHeaderSize); + + if (psnr) { + *psnr = WebPGetPSNR(Y, U, V, *p_out, *p_out_size_bytes); + } + + return webp_success; + } +} + +void AdjustColorspace(uint8* Y, uint8* U, uint8* V, int width, int height) { + int y_width = width; + int y_height = height; + int y_stride = y_width; + int uv_width = ((y_width + 1) >> 1); + int uv_height = ((y_height + 1) >> 1); + int uv_stride = uv_width; + int x, y; + /* convert luma */ + for (y = 0; y < y_height; ++y) { + uint8* const Yrow = Y + y * y_stride; + for (x = 0; x < y_width; ++x) { + /* maps [0..255] to [16..235] */ + Yrow[x] = ((Yrow[x] * 55 + 32) >> 6) + 16; + } + } + /* convert chroma */ + for (y = 0; y < uv_height; ++y) { + uint8* const Urow = U + y * uv_stride; + uint8* const Vrow = V + y * uv_stride; + for (x = 0; x < uv_width; ++x) { + /* maps [0..255] to [16..240] */ + Urow[x] = (((Urow[x] - 127) * 7) >> 3) + 128; + Vrow[x] = (((Vrow[x] - 127) * 7) >> 3) + 128; + } + } +} + +void AdjustColorspaceBack(uint8* Y, uint8* U, uint8* V, int width, int height) { + int y_width = width; + int y_height = height; + int y_stride = y_width; + int uv_width = ((y_width + 1) >> 1); + int uv_height = ((y_height + 1) >> 1); + int uv_stride = uv_width; + int x, y; + /* convert luma */ + for (y = 0; y < y_height; ++y) { + uint8* const Yrow = Y + y * y_stride; + for (x = 0; x < y_width; ++x) { + /* maps [16..235] to [0..255] */ + const int v = ((Yrow[x] - 16) * 149 + 64) >> 7; + Yrow[x] = (v < 0) ? 0 : (v > 255) ? 255u : v; + } + } + /* convert chroma */ + for (y = 0; y < uv_height; ++y) { + uint8* const Urow = U + y * uv_stride; + uint8* const Vrow = V + y * uv_stride; + for (x = 0; x < uv_width; ++x) { + /* maps [0..255] to [16..240] */ + const int ru = (((Urow[x] - 128) * 73) >> 6) + 128; + const int rv = (((Vrow[x] - 128) * 73) >> 6) + 128; + Urow[x] = (ru < 0) ? 0 : (ru > 255) ? 255u : ru; + Vrow[x] = (rv < 0) ? 0 : (rv > 255) ? 255u : rv; + } + } +} + +WebPResult WebPGetInfo(const uint8* data, + int data_size, + int *width, + int *height) { + const uint32 chunk_size = SkipRiffHeader(&data, &data_size); + + if (width) *width = 0; + if (height) *height = 0; + + if (!chunk_size) { + return webp_failure; /* unsupported RIFF header */ + } + + /* Validate raw video data */ + if (data_size < 10) { + return webp_failure; /* not enough data */ + } + + /* check signature */ + if (data[3] != 0x9d || data[4] != 0x01 || data[5] != 0x2a) { + return webp_failure; /* Wrong signature. */ + } else { + const uint32 bits = data[0] | (data[1] << 8) | (data[2] << 16); + + if ((bits & 1)) { /* Not a keyframe. */ + return webp_failure; + } else { + const int profile = (bits >> 1) & 7; + const int show_frame = (bits >> 4) & 1; + const uint32 partition_length = (bits >> 5); + + if (profile > 3) { + return webp_failure; /* unknown profile */ + } + if (!show_frame) { + return webp_failure; /* first frame is invisible! */ + } + if (partition_length >= chunk_size) { + return webp_failure; /* inconsistent size information. */ + } else { + const int w = ((data[7] << 8) | data[6]) & 0x3fff; + const int h = ((data[9] << 8) | data[8]) & 0x3fff; + if (width) *width = w; + if (height) *height = h; + + return webp_success; + } + } + } + return webp_failure; +} +#endif /* HAVE_LIBVPX */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/webpimg.h b/Build/source/libs/gd/libgd-2.1.1/src/webpimg.h new file mode 100644 index 00000000000..8a05429a73c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/webpimg.h @@ -0,0 +1,181 @@ +/*===========================================================================* + - Copyright 2010 Google Inc. + - + - This code is licensed under the same terms as WebM: + - Software License Agreement: http://www.webmproject.org/license/software/ + - Additional IP Rights Grant: http://www.webmproject.org/license/additional/ + *===========================================================================*/ + +/* + * Encoding/Decoding of WebP still image compression format. + * + * 1. WebPDecode: Takes an array of bytes (string) corresponding to the WebP + * encoded image and generates output in the YUV format with + * the color components U, V subsampled to 1/2 resolution along + * each dimension. + * + * 2. YUV420toRGBA: Converts from YUV (with color subsampling) such as produced + * by the WebPDecode routine into 32 bits per pixel RGBA data + * array. This data array can be directly used by the Leptonica + * Pix in-memory image format. + * + * 3. WebPEncode: Takes a Y, U, V data buffers (with color components U and V + * subsampled to 1/2 resolution) and generates the WebP string + * + * 4. RGBAToYUV420: Generates Y, U, V data (with color subsampling) from 32 bits + * per pixel RGBA data buffer. The resulting YUV data can be + * directly fed into the WebPEncode routine. + * + * 5. AdjustColorspace: + * + * 6. AdjustColorspaceBack: + */ + +#ifndef THIRD_PARTY_VP8_VP8IMG_H_ +#define THIRD_PARTY_VP8_VP8IMG_H_ + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +typedef unsigned char uint8; +typedef unsigned int uint32; +typedef enum WebPResultType { + webp_success = 0, + webp_failure = -1 +} WebPResult; + +/* Takes an array of bytes (string) corresponding to the WebP + * encoded image and generates output in the YUV format with + * the color components U, V subsampled to 1/2 resolution along + * each dimension. + * Input: + * 1. data: the WebP data stream (array of bytes) + * 2. data_size: count of bytes in the WebP data stream + * + * Output: + * 3. p_Y/p_U/p_V : pointer to the Y/U/V data buffer (this routine will + * allocate memory for the buffer, fill the buffer with + * appropriate data and transfer owner ship of the buffer + * to caller. Caller is reponsible for freeing the memory). + * Note that the memory for Y, U, V buffers is alloacted + * in one chunk, hence one should call free(*p_Y) only. + * Do not try to free the U and V buffers. + * + * 6. p_width: this routine returns the width of the decoded image here + * 7. p_height: this routine returns the width of the decoded image here + * Return: success/failure + */ +WebPResult WebPDecode(const uint8* data, + int data_size, + uint8** p_Y, + uint8** p_U, + uint8** p_V, + int* p_width, + int* p_height); + +/* WebPEncode: Takes a Y, U, V data buffers (with color components U and V + * subsampled to 1/2 resolution) and generates the WebP string. + * Input: + * 1, 2, 3. Y, U, V: The input YUV data buffers + * 4, 5. y_width, y_height: The width and height of the image whose data + * is in Y, U, V. This matches the Y plane. The U + * and V planes typically have 1/2 width and + * height. + * 6. y_stride: The width (in bytes) of one row of Y data. This may not + * match width if there is end of row padding (e.g., for 32 + * bit row aligment). + * 7. QP: the quantization parameter. This parameter controls the + * compression vs quality tradeoff. Use smaller numbers for better + * quality (compression will be lesser) and vice versa. 20 is a + * good optimal value. + * Output: + * 8. p_out: the output array of bytes corresponding to the encoded WebP + * image. This routine allocates memory for the buffer, fills it + * with appropriate values and transfers ownership to caller. + * Caller responsible for freeing of memory. + * Return: success/failure + */ +WebPResult WebPEncode(const uint8* Y, + const uint8* U, + const uint8* V, + int y_width, + int y_height, + int y_stride, + int uv_width, + int uv_height, + int uv_stride, + int QP, + unsigned char** p_out, + int* p_out_size_bytes, + double* psnr); + +/* Converts from YUV (with color subsampling) such as produced by the WebPDecode + * routine into 32 bits per pixel RGBA data array. This data array can be + * directly used by the Leptonica Pix in-memory image format. + * Input: + * 1, 2, 3. Y, U, V: the input data buffers + * 4. pixwpl: the desired words per line corresponding to the supplied + * output pixdata. + * 5. width, height: the dimensions of the image whose data resides in Y, + * U, V. + * Output: + * 6. pixdata: the output data buffer. Caller should allocate + * height * pixwpl bytes of memory before calling this routine. + */ +void YUV420toRGBA(uint8* Y, + uint8* U, + uint8* V, + int words_per_line, + int width, + int height, + uint32* pixdata); + +/* Generates Y, U, V data (with color subsampling) from 32 bits + * per pixel RGBA data buffer. The resulting YUV data can be directly fed into + * the WebPEncode routine. + * Input: + * 1. pix data input rgba data buffer + * 2. words per line corresponding to pixdata + * 3, 4. image width and height respectively + * Output: + * 5, 6, 7. Output YUV data buffers + */ +void RGBAToYUV420(uint32* pixdata, + int words_per_line, + int width, + int height, + uint8* Y, + uint8* U, + uint8* V); + +/* This function adjust from YUV420J (jpeg decoding) to YUV420 (webp input) + * Hints: http://en.wikipedia.org/wiki/YCbCr + */ +void AdjustColorspace(uint8* Y, uint8* U, uint8* V, int width, int height); + +/* Inverse function: convert from YUV420 to YUV420J */ +void AdjustColorspaceBack(uint8* Y, uint8* U, uint8* V, int width, int height); + +/* Checks WebP image header and outputs height and width information of + * the image + * + * Input: + * 1. data: the WebP data stream (array of bytes) + * 2. data_size: count of bytes in the WebP data stream + * + * Outut: + * width/height: width and height of the image + * + * Return: success/failure + */ +WebPResult WebPGetInfo(const uint8* data, + int data_size, + int *width, + int *height); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* THIRD_PARTY_VP8_VP8IMG_H_ */ diff --git a/Build/source/libs/gd/libgd-2.1.1/src/webpng.c b/Build/source/libs/gd/libgd-2.1.1/src/webpng.c new file mode 100644 index 00000000000..74231795d10 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/src/webpng.c @@ -0,0 +1,243 @@ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +/* Bring in the gd library functions */ +#include "gd.h" + +/* Bring in standard I/O and string manipulation functions */ +#include <stdio.h> +#include <stdlib.h> /* for atoi() */ +#include <string.h> + +#ifdef _WIN32 +#include <process.h> +int +getpid () +{ + return _getpid (); +} +#else +#include <unistd.h> /* for getpid(), unlink() */ +#endif +int +main (int argc, char **argv) +{ + FILE *in; + FILE *out; + char outFn[20]; + int useStdinStdout = 0; + + /* Declare our image pointer */ + gdImagePtr im = 0; + int i; + /* We'll clear 'no' once we know the user has made a + reasonable request. */ + int no = 1; + /* We'll set 'write' once we know the user's request + requires that the image be written back to disk. */ + int write = 0; + /* C programs always get at least one argument; we want at + least one more (the image), more in practice. */ + if (argc < 2 || !strcmp (argv[1], "--help")) { + no = 1; + goto usage; + } + + /* The last argument should be the image. Open the file. */ + if (strcmp ("-", argv[argc - 1]) == 0) { + /* - is synonymous with STDIN */ + useStdinStdout = 1; + in = stdin; + } else { + in = fopen (argv[argc - 1], "rb"); + } + if (!in) { + fprintf(stderr, "can't open file %s.\n", argv[argc - 1]); + exit (1); + } + /* Now load the image. */ +#ifdef HAVE_LIBPNG + im = gdImageCreateFromPng (in); +#else + fprintf(stderr, "No PNG library support.\n"); +#endif + fclose (in); + /* If the load failed, it must not be a PNG file. */ + if (!im) { + fprintf (stderr, + "Error: %s is not a valid PNG file.\n", argv[argc - 1]); + exit (1); + } + /* Consider each argument in turn. */ + for (i = 1; (i < (argc - 1)); i++) { + /* -i turns on and off interlacing. */ + if (!strcmp (argv[i], "--help")) { + /* Every program should use this for help! :) */ + no = 1; + goto usage; + } else if (!strcmp (argv[i], "-i")) { + if (i == (argc - 2)) { + fprintf(stderr, "-i specified without y or n.\n"); + no = 1; + goto usage; + } + if (!strcmp (argv[i + 1], "y")) { + /* Set interlace. */ + gdImageInterlace (im, 1); + } else if (!strcmp (argv[i + 1], "n")) { + /* Clear interlace. */ + gdImageInterlace (im, 0); + } else { + fprintf(stderr, "Error: -i specified without y or n.\n"); + no = 1; + goto usage; + } + i++; + no = 0; + write = 1; + } else if (!strcmp (argv[i], "-t")) { + /* Set transparent index (or none). */ + int index; + if (i == (argc - 2)) { + fprintf (stderr, + "Error: -t specified without a color table index.\n"); + no = 1; + goto usage; + } + if (!strcmp (argv[i + 1], "none")) { + /* -1 means not transparent. */ + gdImageColorTransparent (im, -1); + } else { + /* OK, get an integer and set the index. */ + index = atoi (argv[i + 1]); + gdImageColorTransparent (im, index); + } + i++; + write = 1; + no = 0; + } else if (!strcmp (argv[i], "-l")) { + /* List the colors in the color table. */ + int j; + if (!im->trueColor) { + /* Tabs used below. */ + printf ("Index Red Green Blue Alpha\n"); + for (j = 0; (j < gdImageColorsTotal (im)); j++) { + /* Use access macros to learn colors. */ + printf ("%d %d %d %d %d\n", + j, + gdImageRed (im, j), + gdImageGreen (im, j), + gdImageBlue (im, j), gdImageAlpha (im, j)); + } + } else { + printf ("Truecolor image, no palette entries to list.\n"); + } + no = 0; + } else if (!strcmp (argv[i], "-d")) { + /* Output dimensions, etc. */ + int t; + printf ("Width: %d Height: %d Colors: %d\n", + gdImageSX (im), gdImageSY (im), gdImageColorsTotal (im)); + t = gdImageGetTransparent (im); + if (t != (-1)) { + printf ("First 100%% transparent index: %d\n", t); + } else { + /* -1 means the image is not transparent. */ + printf ("First 100%% transparent index: none\n"); + } + if (gdImageGetInterlaced (im)) { + printf ("Interlaced: yes\n"); + } else { + printf ("Interlaced: no\n"); + } + no = 0; + } else if (!strcmp (argv[i], "-a")) { + /* Alpha channel info -- thanks to Wez Furlong */ + int maxx, maxy, x, y, alpha, pix, nalpha = 0; + + maxx = gdImageSX (im); + maxy = gdImageSY (im); + + printf ("alpha channel information:\n"); + + if (im->trueColor) { + for (y = 0; y < maxy; y++) { + for (x = 0; x < maxx; x++) { + pix = gdImageGetPixel (im, x, y); + alpha = gdTrueColorGetAlpha (pix); + + if (alpha > gdAlphaOpaque) { + /* Use access macros to learn colors. */ + printf ("%d %d %d %d\n", + gdTrueColorGetRed (pix), + gdTrueColorGetGreen (pix), + gdTrueColorGetBlue (pix), alpha); + nalpha++; + } + + } + } + } else + printf ("NOT a true color image\n"); + no = 0; + printf ("%d alpha channels\n", nalpha); + + } else { + fprintf(stderr, "Unknown argument: %s\n", argv[i]); + break; + } + } +usage: + if (no) { + /* If the command failed, output an explanation. */ + fprintf (stderr, + "Usage: webpng [-i y|n ] [-l] [-t index|none ] [-d] pngname.png\n" + " -i [y|n] Turns on/off interlace\n" + " -l Prints the table of color indexes\n" + " -t [index] Set the transparent color to the specified index (0-255 or \"none\")\n" + " -d Reports the dimensions and other characteristics of the image.\n" + " -a Prints all alpha channels that are not 100%% opaque.\n" + "\n" + "If you specify '-' as the input file, stdin/stdout will be used input/output.\n"); + } + if (write) { + if (useStdinStdout) { + out = stdout; + } else { + /* Open a temporary file. */ + + /* "temp.tmp" is not good temporary filename. */ + sprintf (outFn, "webpng.tmp%d", getpid ()); + out = fopen (outFn, "wb"); + + if (!out) { + fprintf(stderr, "Unable to write to %s -- exiting\n", outFn); + exit (1); + } + } + + /* Write the new PNG. */ +#ifdef HAVE_LIBPNG + gdImagePng (im, out); +#else + fprintf(stderr, "No PNG library support.\n"); +#endif + if (!useStdinStdout) { + fclose (out); + /* Erase the old PNG. */ + unlink (argv[argc - 1]); + /* Rename the new to the old. */ + if (rename (outFn, argv[argc - 1]) != 0) { + perror ("rename"); + exit (1); + } + } + } + /* Delete the image from memory. */ + if (im) { + gdImageDestroy (im); + } + /* All's well that ends well. */ + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/test/gdtest.gd2 b/Build/source/libs/gd/libgd-2.1.1/test/gdtest.gd2 Binary files differnew file mode 100644 index 00000000000..aaa124f567c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/test/gdtest.gd2 diff --git a/Build/source/libs/gd/libgd-2.1.1/test/gdtest.png b/Build/source/libs/gd/libgd-2.1.1/test/gdtest.png Binary files differnew file mode 100644 index 00000000000..1d480c6a4f4 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/test/gdtest.png diff --git a/Build/source/libs/gd/libgd-2.1.1/test/gdtest_200_300_150_100.png b/Build/source/libs/gd/libgd-2.1.1/test/gdtest_200_300_150_100.png Binary files differnew file mode 100644 index 00000000000..535474e474a --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/test/gdtest_200_300_150_100.png diff --git a/Build/source/libs/gd/libgd-2.1.1/test/gdtest_merge.png b/Build/source/libs/gd/libgd-2.1.1/test/gdtest_merge.png Binary files differnew file mode 100644 index 00000000000..4381bbfe2fc --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/test/gdtest_merge.png diff --git a/Build/source/libs/gd/libgd-2.1.1/test/gdtest_wbmp_to_png.png b/Build/source/libs/gd/libgd-2.1.1/test/gdtest_wbmp_to_png.png Binary files differnew file mode 100644 index 00000000000..d6baf5491fe --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/test/gdtest_wbmp_to_png.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/CMakeLists.txt new file mode 100644 index 00000000000..5f8706fdb02 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/CMakeLists.txt @@ -0,0 +1,78 @@ + +if (BUILD_TEST) + SET(DART_TESTING_TIMEOUT 5) + + INCLUDE(Dart) + + set(GDTEST_SOURCE_DIR ${GD_SOURCE_DIR}/tests/gdtest) + + IF (ENABLE_GCOV AND CMAKE_COMPILER_IS_GNUCC) + SET(CMAKE_BUILD_TYPE TESTINGGCOV) + SET(CMAKE_CXX_FLAGS_TESTINGGCOV "-g3 -O0") + SET(CMAKE_C_FLAGS_TESTINGGCOV "-g3 -O0") + endif (ENABLE_GCOV AND CMAKE_COMPILER_IS_GNUCC) + + message(STATUS "gd include dir: ${GD_INCLUDE_DIR}" ) + message(STATUS "gd libs dir: ${GD_LIBS_DIR}" ) + + include_directories (BEFORE ${GD_INCLUDE_DIR} "${GDTEST_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" "${CMAKE_BINARY_DIR}/tests/gdtest") + + SET(TESTS_DIRS + gdtest + bmp + gd + gd2 + gdimagearc + gdimagecolorclosest + gdimagecolordeallocate + gdimagecolorexact + gdimagecolorreplace + gdimagecolorresolve + gdimagecolortransparent + gdimagecopy + gdimagecopyrotated + gdimagefill + gdimagefilledellipse + gdimagefilledpolygon + gdimagefilledrectangle + gdimagefilltoborder + gdimageline + gdimageopenpolygon + gdimagepixelate + gdimagepolygon + gdimagerectangle + gdimagerotate + gdimagescatterex + gdimagesetpixel + gdnewfilectx + gdtiled + gif + tga + wbmp + ) + + IF(FREETYPE_FOUND) + LIST(APPEND TESTS_DIRS freetype gdimagestringft gdimagestringftex) + ENDIF(FREETYPE_FOUND) + + IF(JPEG_FOUND) + LIST(APPEND TESTS_DIRS jpeg) + ENDIF(JPEG_FOUND) + + IF(PNG_FOUND) + LIST(APPEND TESTS_DIRS png) + ENDIF(PNG_FOUND) + + IF(TIFF_FOUND) + LIST(APPEND TESTS_DIRS tiff) + ENDIF(TIFF_FOUND) + + IF(XPM_FOUND) + LIST(APPEND TESTS_DIRS xpm) + ENDIF(XPM_FOUND) + + FOREACH(test_dir ${TESTS_DIRS}) + add_subdirectory (${test_dir}) + ENDFOREACH(test_dir) + +endif (BUILD_TEST) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/Makefile.am b/Build/source/libs/gd/libgd-2.1.1/tests/Makefile.am new file mode 100644 index 00000000000..d5ae473748c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/Makefile.am @@ -0,0 +1,368 @@ +noinst_LIBRARIES = libgdtest.a + +libgdtest_a_SOURCES = \ + gdtest/gdtest.c \ + gdtest/gdtest.h \ + ../src/gdhelpers.c + +check_PROGRAMS = \ + gd2/gd2_empty_file \ + gdimagesetpixel/bug00186 \ + gdimagestringftex/gdimagestringftex_returnfontpathname \ + gdimageline/gdimageline_aa_outofrange \ + gdimagerectangle/bug00003 \ + gdimagerectangle/bug00106_gdimagerectangle \ + gd/gd_null \ + gd/gd_num_colors \ + tga/tga_null \ + gdimagepixelate/gdimagepixelate \ + gdimagecopy/bug00007 \ + gdnewfilectx/gdnewfilectx_null \ + gdimagefilledrectangle/bug00078 \ + gdimagefilledrectangle/bug00004 \ + gdimagefilledrectangle/bug00106_gdimagefilledrectangle \ + gdimagecolordeallocate/gdimagecolordeallocate \ + wbmp/wbmp_null \ + gdimagecolortransparent/gdimagecolortransparent \ + gif/bug00005_2 \ + gif/gif_null \ + gif/bug00181 \ + gif/bug00227 \ + bmp/bmp_null \ + gdinterpolatedscale/gdTrivialResize \ + gdinterpolatedscale/gdModesAndPalettes \ + gd/gd_versiontest \ + gdimagefilter/gdCopyBlurred \ + gdimagefile/gdnametest + +EXTRA_PROGRAMS = \ + gdimagestringft/gdimagestringft_bbox \ + gdtiled/bug00032 \ + gd2/gd2_im2im \ + gd2/gd2_null \ + gd2/gd2_read \ + gdimagearc/bug00079 \ + gdimageline/gdimageline_aa \ + gdimageline/bug00072 \ + gdimageline/bug00077 \ + gdimageline/bug00111 \ + gdimageline/gdimageline_bug5 \ + gdimageline/gdImageAALine_thickness \ + gdimageopenpolygon/gdimageopenpolygon2 \ + gdimageopenpolygon/gdimageopenpolygon1 \ + gdimageopenpolygon/gdimageopenpolygon0 \ + gdimageopenpolygon/gdimageopenpolygon3 \ + gd/gd_im2im \ + gdimagecopy/bug00081 \ + gdimagecopyrotated/bug00020 \ + gdimagepolygon/gdimagepolygon0 \ + gdimagepolygon/gdimagepolygon3 \ + gdimagepolygon/gdimagepolygon1 \ + gdimagepolygon/gdimagepolygon2 \ + gdimagecolorresolve/gdimagecolorresolve \ + gdimagefilledpolygon/gdimagefilledpolygon0 \ + gdimagefilledpolygon/gdimagefilledpolygon3 \ + gdimagefilledpolygon/gdimagefilledpolygon2 \ + gdimagefilledpolygon/gdimagefilledpolygon1 \ + gdimagefilledpolygon/bug00100 \ + gdimagecolorreplace/gdimagecolorreplace \ + gdimagefill/bug00002_2 \ + gdimagefill/bug00002_1 \ + gdimagefill/bug00002_4 \ + gdimagefill/bug00002_3 \ + gdimagecolorclosest/gdimagecolorclosest \ + gif/bug00005 \ + gif/gif_im2im \ + gif/bug00066 \ + gif/bug00006 \ + gif/bug00060 \ + gdimagecolorexact/gdimagecolorexact \ + gdimagefilledellipse/bug00191 \ + gdimagefilledellipse/bug00010 \ + xpm/bug00185 \ + xpm/color_name \ + xpm/bug00166 \ + jpeg/jpeg_empty_file \ + jpeg/jpeg_resolution \ + jpeg/jpeg_im2im \ + jpeg/jpeg_null \ + jpeg/jpeg_read \ + png/png_null \ + png/bug00033 \ + png/bug00193 \ + png/bug00011 \ + png/bug00088 \ + png/png_resolution \ + png/bug00086 \ + png/png_im2im \ + wbmp/wbmp_im2im \ + tiff/tiff_null \ + tiff/tiff_im2im \ + freetype/bug00132 \ + bmp/bmp_im2im \ + gdimagescatterex/bug00208_1 \ + gdimagescatterex/bug00208_2 \ + gdimagefilltoborder/bug00037 \ + gdimagerotate/php_bug_64898 \ + gdimagerotate/bug00067 + +if HAVE_LIBXPM +check_PROGRAMS += \ + xpm/bug00185 \ + xpm/color_name \ + xpm/bug00166 +endif + +if HAVE_LIBJPEG +check_PROGRAMS += \ + jpeg/jpeg_empty_file \ + jpeg/jpeg_im2im \ + jpeg/jpeg_null +if HAVE_LIBPNG +check_PROGRAMS += \ + jpeg/jpeg_resolution \ + jpeg/jpeg_read +endif +endif + +if HAVE_LIBZ +check_PROGRAMS += \ + gd2/gd2_null +endif + +if HAVE_LIBPNG +if HAVE_LIBZ +check_PROGRAMS += \ + gd2/gd2_read \ + gd2/gd2_im2im \ + gdtiled/bug00032 +endif +check_PROGRAMS += \ + gdimagestringft/gdimagestringft_bbox \ + gdimagearc/bug00079 \ + gdimageline/gdimageline_aa \ + gdimageline/bug00072 \ + gdimageline/bug00077 \ + gdimageline/bug00111 \ + gdimageline/gdimageline_bug5 \ + gdimageline/gdImageAALine_thickness \ + gdimageopenpolygon/gdimageopenpolygon2 \ + gdimageopenpolygon/gdimageopenpolygon1 \ + gdimageopenpolygon/gdimageopenpolygon0 \ + gdimageopenpolygon/gdimageopenpolygon3 \ + gd/gd_im2im \ + gdimagecopy/bug00081 \ + gdimagecopyrotated/bug00020 \ + gdimagepolygon/gdimagepolygon0 \ + gdimagepolygon/gdimagepolygon3 \ + gdimagepolygon/gdimagepolygon1 \ + gdimagepolygon/gdimagepolygon2 \ + gdimagecolorresolve/gdimagecolorresolve \ + gdimagefilledpolygon/gdimagefilledpolygon0 \ + gdimagefilledpolygon/gdimagefilledpolygon3 \ + gdimagefilledpolygon/gdimagefilledpolygon2 \ + gdimagefilledpolygon/gdimagefilledpolygon1 \ + gdimagefilledpolygon/bug00100 \ + gdimagecolorreplace/gdimagecolorreplace \ + gdimagefill/bug00002_2 \ + gdimagefill/bug00002_1 \ + gdimagefill/bug00002_4 \ + gdimagefill/bug00002_3 \ + gdimagecolorclosest/gdimagecolorclosest \ + gif/bug00005 \ + gif/gif_im2im \ + gif/bug00066 \ + gif/bug00006 \ + gif/bug00060 \ + gdimagecolorexact/gdimagecolorexact \ + gdimagefilledellipse/bug00191 \ + gdimagefilledellipse/bug00010 \ + png/png_null \ + png/bug00033 \ + png/bug00193 \ + png/bug00011 \ + png/bug00088 \ + png/png_resolution \ + png/bug00086 \ + png/png_im2im \ + wbmp/wbmp_im2im \ + bmp/bmp_im2im \ + gdimagescatterex/bug00208_1 \ + gdimagescatterex/bug00208_2 \ + gdimagefilltoborder/bug00037 \ + gdimagerotate/php_bug_64898 \ + gdimagerotate/bug00067 +endif + +if HAVE_LIBTIFF +check_PROGRAMS += \ + tiff/tiff_null \ + tiff/tiff_im2im +endif + +if HAVE_LIBFREETYPE +check_PROGRAMS += + freetype/bug00132 +endif + +LDADD = libgdtest.a ../src/libgd.la +AM_CPPFLAGS = -I$(top_srcdir)/src -I $(top_srcdir)/tests/gdtest + +TESTS = $(check_PROGRAMS) + +EXTRA_DIST = \ + gdtest/test_config.h.cmake \ + xpm/bug00166.xpm \ + xpm/bug00185.xpm \ + xpm/bug00185_damaged.xpm \ + xpm/color_name.xpm \ + gdtiled/bug00032_exp.png \ + jpeg/conv_test.jpeg \ + jpeg/conv_test_exp.png \ + jpeg/empty.jpeg \ + gd2/conv_test.gd2 \ + gd2/conv_gd2_exp.gd2 \ + gd2/empty.gd2 \ + gd2/conv_test_exp.png \ + gdimagearc/bug00079_exp.png \ + png/bug00088_2.png \ + png/bug00088_1_exp.png \ + png/bug00033.png \ + png/bug00088_2_exp.png \ + png/bug00088_1.png \ + png/emptyfile \ + gdimageline/gdimageline_aa_b_0_exp.png \ + gdimageline/gdimageline_aa_c_0_exp.png \ + gdimageline/gdimageline_aa_d_1_exp.png \ + gdimageline/gdimageline_aa_a_1_exp.png \ + gdimageline/gdimageline_aa_d_0_exp.png \ + gdimageline/bug00111_exp.png \ + gdimageline/gdimageline_aa_c_1_exp.png \ + gdimageline/gdimageline_aa_a_0_exp.png \ + gdimageline/gdimageline_aa_b_1_exp.png \ + gdimageline/bug00072_exp.png \ + gdimageline/bug00077_exp.png \ + gdimageopenpolygon/gdimageopenpolygon0.png \ + gdimageopenpolygon/gdimageopenpolygon1.png \ + gdimageopenpolygon/gdimageopenpolygon2.png \ + gdimageopenpolygon/gdimageopenpolygon3.png \ + gd/crafted_num_colors.gd \ + gdimagecopy/bug00081_exp.png \ + gdimagecopyrotated/bug00020_exp.png \ + gdimagepolygon/gdimagepolygon1.png \ + gdimagepolygon/gdimagepolygon3.png \ + gdimagepolygon/gdimagepolygon0.png \ + gdimagepolygon/gdimagepolygon2.png \ + gdimagefilledpolygon/gdimagefilledpolygon0.png \ + gdimagefilledpolygon/gdimagefilledpolygon1.png \ + gdimagefilledpolygon/gdimagefilledpolygon3.png \ + gdimagefilledpolygon/gdimagefilledpolygon2.png \ + gdimagefilledpolygon/bug00100.png \ + gdimagefill/bug00002_3_exp.png \ + gdimagefill/bug00002_2_exp.png \ + gdimagefill/bug00002_1_exp.png \ + gdimagefill/bug00002_4_exp.png \ + gif/bug00005_0.gif \ + gif/bug00005_1.gif \ + gif/bug00005_3.gif \ + gif/bug00005_2.gif \ + gif/bug00060.gif \ + gif/bug00066_exp.png \ + gif/bug00005_2_exp.png \ + gif/bug00066.gif \ + gdimagefilledellipse/bug00191.png \ + gdimagefilledellipse/bug00010_exp.png \ + gdimagescatterex/bug00208_2.png \ + gdimagescatterex/bug00208.png \ + gdimagescatterex/bug00208_1.png \ + freetype/bug00132_exp.png \ + freetype/DejaVuSans.ttf \ + gdimagestringft/CMakeLists.txt \ + gdtest/CMakeLists.txt \ + xpm/CMakeLists.txt \ + gdtiled/CMakeLists.txt \ + jpeg/CMakeLists.txt \ + gd2/CMakeLists.txt \ + gdimagesetpixel/CMakeLists.txt \ + gdimagearc/CMakeLists.txt \ + png/CMakeLists.txt \ + gdimagestringftex/CMakeLists.txt \ + gdimageline/CMakeLists.txt \ + gdimageopenpolygon/CMakeLists.txt \ + gdimagerectangle/CMakeLists.txt \ + gd/CMakeLists.txt \ + tga/CMakeLists.txt \ + gdimagepixelate/CMakeLists.txt \ + tiff/CMakeLists.txt \ + gdimagecopy/CMakeLists.txt \ + CMakeLists.txt \ + gdnewfilectx/CMakeLists.txt \ + gdimagefilledrectangle/CMakeLists.txt \ + gdimagecopyrotated/CMakeLists.txt \ + gdimagepolygon/CMakeLists.txt \ + gdimagecolordeallocate/CMakeLists.txt \ + wbmp/CMakeLists.txt \ + gdimagecolorresolve/CMakeLists.txt \ + gdimagefilledpolygon/CMakeLists.txt \ + gdimagecolorreplace/CMakeLists.txt \ + gdimagefill/CMakeLists.txt \ + gdimagecolorclosest/CMakeLists.txt \ + gdimagecolortransparent/CMakeLists.txt \ + gif/CMakeLists.txt \ + gdimagecolorexact/CMakeLists.txt \ + gdimagefilledellipse/CMakeLists.txt \ + bmp/CMakeLists.txt \ + gdimagescatterex/CMakeLists.txt \ + gdimagefilltoborder/CMakeLists.txt \ + freetype/CMakeLists.txt \ + gdimagerotate/php_bug_64898.png \ + gdimagerotate/php_bug_64898_exp.png \ + gdimagerotate/remirh128.jpg \ + gdimagerotate/bug00067_000_exp.png \ + gdimagerotate/bug00067_015_exp.png \ + gdimagerotate/bug00067_030_exp.png \ + gdimagerotate/bug00067_045_exp.png \ + gdimagerotate/bug00067_060_exp.png \ + gdimagerotate/bug00067_075_exp.png \ + gdimagerotate/bug00067_090_exp.png \ + gdimagerotate/bug00067_105_exp.png \ + gdimagerotate/bug00067_120_exp.png \ + gdimagerotate/bug00067_135_exp.png \ + gdimagerotate/bug00067_150_exp.png \ + gdimagerotate/bug00067_165_exp.png \ + gdimagerotate/bug00067_180_exp.png \ + gdimagefile/img-ref.tga \ + gdimagefile/img-ref.xbm \ + gdimagefile/img-ref.xpm \ + gdimageline/gdImageAALine_thickness_exp.png + +CLEANFILES = \ + a.png \ + bmp_im2im_dst.bmp \ + bmp_im2im_src.bmp \ + bug00132.c_35_diff.png \ + bug00132.c_35_out.png \ + bug00181.gif \ + bug00181a.gif \ + bug00227.gif \ + gd2_im2im_dst.gd2 \ + gd2_im2im_src.gd2 \ + gd_im2im_dst.gd \ + gd_im2im_src.gd \ + gdimageline_aa.c_38_diff.png \ + gdimageline_aa.c_38_out.png \ + gdimagestringft_bbox.png \ + gif_im2im_dst.gif \ + gif_im2im_src.gif \ + jpeg_im2im_dst.jpeg \ + jpeg_im2im_src.jpeg \ + jpeg_read.c_25_diff.png \ + jpeg_read.c_25_out.png \ + png_im2im_dst.png \ + png_im2im_src.png \ + tiff_im2im_dst.tiff \ + tiff_im2im_src.tiff \ + wbmp/wbmp_im2im_dst.wbmp \ + wbmp/wbmp_im2im_src.wbmp \ + wbmp_im2im_dst.wbmp \ + wbmp_im2im_src.wbmp diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/bmp/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/bmp/CMakeLists.txt new file mode 100644 index 00000000000..751c303a756 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/bmp/CMakeLists.txt @@ -0,0 +1,11 @@ + +SET(TESTS_FILES + bmp_im2im + bmp_null +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest ${GD_LIB}) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/bmp/bmp_im2im.c b/Build/source/libs/gd/libgd-2.1.1/tests/bmp/bmp_im2im.c new file mode 100644 index 00000000000..2beb2db4206 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/bmp/bmp_im2im.c @@ -0,0 +1,66 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr src, dst; + int r, g, b; + void *p; + int size = 0; + int status = 0; + CuTestImageResult result = {0, 0}; + + src = gdImageCreate(100, 100); + if (src == NULL) { + printf("could not create src\n"); + return 1; + } + r = gdImageColorAllocate(src, 0xFF, 0, 0); + g = gdImageColorAllocate(src, 0, 0xFF, 0); + b = gdImageColorAllocate(src, 0, 0, 0xFF); + gdImageFilledRectangle(src, 0, 0, 99, 99, r); + gdImageRectangle(src, 20, 20, 79, 79, g); + gdImageEllipse(src, 70, 25, 30, 20, b); + +#define OUTPUT_BMP(name) do { \ + FILE *fp; \ + \ + fp = fopen("bmp_im2im_" #name ".bmp", "wb"); \ + if (fp) { \ + gdImageBmp(name, fp, 1); \ + fclose(fp); \ + } \ + } while (0) + + OUTPUT_BMP(src); + p = gdImageBmpPtr(src, &size, 1); + if (p == NULL) { + status = 1; + printf("p is null\n"); + goto door0; + } + if (size <= 0) { + status = 1; + printf("size is non-positive\n"); + goto door1; + } + + dst = gdImageCreateFromBmpPtr(size, p); + if (dst == NULL) { + status = 1; + printf("could not create dst\n"); + goto door1; + } + OUTPUT_BMP(dst); + gdTestImageDiff(src, dst, NULL, &result); + if (result.pixels_changed > 0) { + status = 1; + printf("pixels changed: %d\n", result.pixels_changed); + } + gdImageDestroy(dst); +door1: + gdFree(p); +door0: + gdImageDestroy(src); + return status; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/bmp/bmp_null.c b/Build/source/libs/gd/libgd-2.1.1/tests/bmp/bmp_null.c new file mode 100644 index 00000000000..08ed8377736 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/bmp/bmp_null.c @@ -0,0 +1,14 @@ +#include "gd.h" + +int main() +{ + gdImagePtr im; + + im = gdImageCreateFromBmp(NULL); + if (im != NULL) { + gdImageDestroy(im); + return 1; + } + gdImageBmp(im, NULL, 0); /* noop safely */ + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/freetype/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/freetype/CMakeLists.txt new file mode 100644 index 00000000000..201d19a5575 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/freetype/CMakeLists.txt @@ -0,0 +1,9 @@ +SET(TESTS_FILES +# bug00132 +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/freetype/DejaVuSans.ttf b/Build/source/libs/gd/libgd-2.1.1/tests/freetype/DejaVuSans.ttf Binary files differnew file mode 100644 index 00000000000..3299ee5572f --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/freetype/DejaVuSans.ttf diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/freetype/bug00132.c b/Build/source/libs/gd/libgd-2.1.1/tests/freetype/bug00132.c new file mode 100644 index 00000000000..88cdfc695a3 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/freetype/bug00132.c @@ -0,0 +1,42 @@ +/* $Id$ */ + +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" +#include "gdfontl.h" + +int main() +{ + gdImagePtr im; + int error = 0; + char path[2048]; + const char *file_exp = "bug00132_exp.png"; + char *ret = NULL; + + im = gdImageCreateTrueColor(50, 30); + + if (!im) { + printf("can't get truecolor image\n"); + return 1; + } + + gdImageAlphaBlending(im, 0); + gdImageFilledRectangle(im, 0, 0, 200, 200, gdTrueColorAlpha(0, 0, 0, 127)); + + sprintf(path, "%s/freetype/DejaVuSans.ttf", GDTEST_TOP_DIR); + + ret = gdImageStringFT(im, NULL, - 0xFFFFFF, path, 14.0, 0.0, 10, 20, "ϑ θ"); + if (ret) { + error = 1; + printf("%s\n", ret); + } else { + sprintf(path, "%s/freetype/%s", GDTEST_TOP_DIR, file_exp); + if (!gdAssertImageEqualsToFile(path, im)) { + error = 1; + printf("Reference image and destination differ\n"); + } + } + gdImageDestroy(im); + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/freetype/bug00132_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/freetype/bug00132_exp.png Binary files differnew file mode 100644 index 00000000000..c45495e618f --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/freetype/bug00132_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gd/CMakeLists.txt new file mode 100644 index 00000000000..c5327171ba0 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd/CMakeLists.txt @@ -0,0 +1,13 @@ + +SET(TESTS_FILES + gd_im2im + gd_null + gd_num_colors + gd_versiontest +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd/crafted_num_colors.gd b/Build/source/libs/gd/libgd-2.1.1/tests/gd/crafted_num_colors.gd Binary files differnew file mode 100644 index 00000000000..45c944cc29f --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd/crafted_num_colors.gd diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd/gd_im2im.c b/Build/source/libs/gd/libgd-2.1.1/tests/gd/gd_im2im.c new file mode 100644 index 00000000000..a7a2226e719 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd/gd_im2im.c @@ -0,0 +1,66 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr src, dst; + int r, g, b; + void *p; + int size = 0; + int status = 0; + CuTestImageResult result = {0, 0}; + + src = gdImageCreate(100, 100); + if (src == NULL) { + printf("could not create src\n"); + return 1; + } + r = gdImageColorAllocate(src, 0xFF, 0, 0); + g = gdImageColorAllocate(src, 0, 0xFF, 0); + b = gdImageColorAllocate(src, 0, 0, 0xFF); + gdImageFilledRectangle(src, 0, 0, 99, 99, r); + gdImageRectangle(src, 20, 20, 79, 79, g); + gdImageEllipse(src, 70, 25, 30, 20, b); + +#define OUTPUT_GD(x) do { \ + FILE *fp; \ + \ + fp = fopen("gd_im2im_" #x ".gd", "wb"); \ + if (fp) { \ + gdImageGd(x, fp); \ + fclose(fp); \ + } \ + } while (0) + + OUTPUT_GD(src); + p = gdImageGdPtr(src, &size); + if (p == NULL) { + status = 1; + printf("p is null\n"); + goto door0; + } + if (size <= 0) { + status = 1; + printf("size is non-positive\n"); + goto door1; + } + + dst = gdImageCreateFromGdPtr(size, p); + if (dst == NULL) { + status = 1; + printf("could not create dst\n"); + goto door1; + } + OUTPUT_GD(dst); + gdTestImageDiff(src, dst, NULL, &result); + if (result.pixels_changed > 0) { + status = 1; + printf("pixels changed: %d\n", result.pixels_changed); + } + gdImageDestroy(dst); +door1: + gdFree(p); +door0: + gdImageDestroy(src); + return status; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd/gd_null.c b/Build/source/libs/gd/libgd-2.1.1/tests/gd/gd_null.c new file mode 100644 index 00000000000..c0594662f1c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd/gd_null.c @@ -0,0 +1,14 @@ +#include "gd.h" + +int main() +{ + gdImagePtr im; + + im = gdImageCreateFromGd(NULL); + if (im != NULL) { + gdImageDestroy(im); + return 1; + } + gdImageGd(im, NULL); /* noop safely */ + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd/gd_num_colors.c b/Build/source/libs/gd/libgd-2.1.1/tests/gd/gd_num_colors.c new file mode 100644 index 00000000000..7d919361925 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd/gd_num_colors.c @@ -0,0 +1,24 @@ +#include "gd.h" +#include <stdio.h> +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + char path[1024]; + FILE* fp; + + sprintf(path, "%s/gd/crafted_num_colors.gd", GDTEST_TOP_DIR); + + fp = fopen(path, "rb"); + if (!fp) { + return 1; + } + im = gdImageCreateFromGd(fp); + fclose(fp); + if (im) { + gdImageDestroy(im); + return 1; + } + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd/gd_versiontest.c b/Build/source/libs/gd/libgd-2.1.1/tests/gd/gd_versiontest.c new file mode 100644 index 00000000000..1aa1a67b3d9 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd/gd_versiontest.c @@ -0,0 +1,21 @@ +#include <string.h> + +#include "gd.h" +#include "gdtest.h" + + +int main() +{ + char buffer[100]; + + gdTestAssert(GD_MAJOR_VERSION == gdMajorVersion()); + gdTestAssert(GD_MINOR_VERSION == gdMinorVersion()); + gdTestAssert(GD_RELEASE_VERSION == gdReleaseVersion()); + gdTestAssert(strcmp(GD_EXTRA_VERSION, gdExtraVersion()) == 0); + + sprintf(buffer, "%d.%d.%d%s", GD_MAJOR_VERSION, GD_MINOR_VERSION, + GD_RELEASE_VERSION, GD_EXTRA_VERSION); + gdTestAssert(strcmp(GD_VERSION_STRING, gdVersionString()) == 0); + + return gdNumFailures(); +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd2/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/CMakeLists.txt new file mode 100644 index 00000000000..68a064c0fbd --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/CMakeLists.txt @@ -0,0 +1,13 @@ + +SET(TESTS_FILES + gd2_read + gd2_empty_file + gd2_im2im + gd2_null +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd2/conv_gd2_exp.gd2 b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/conv_gd2_exp.gd2 new file mode 100644 index 00000000000..e69de29bb2d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/conv_gd2_exp.gd2 diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd2/conv_test.gd2 b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/conv_test.gd2 Binary files differnew file mode 100644 index 00000000000..1c64b46d9ae --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/conv_test.gd2 diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd2/conv_test_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/conv_test_exp.png Binary files differnew file mode 100644 index 00000000000..b4bc3fad9f4 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/conv_test_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd2/empty.gd2 b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/empty.gd2 new file mode 100644 index 00000000000..e69de29bb2d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/empty.gd2 diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd2/gd2_empty_file.c b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/gd2_empty_file.c new file mode 100644 index 00000000000..289debc541e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/gd2_empty_file.c @@ -0,0 +1,30 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + FILE *fp; + char path[1024]; + + sprintf(path, "%s/gd2/empty.gd2", GDTEST_TOP_DIR); + + fp = fopen(path, "rb"); + if (!fp) { + printf("failed, cannot open file (%s)\n", path); + return 1; + } + + im = gdImageCreateFromGd2(fp); + fclose(fp); + + if (!im) { + return 0; + } else { + gdImageDestroy(im); + return 1; + } +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd2/gd2_im2im.c b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/gd2_im2im.c new file mode 100644 index 00000000000..7745fa5973e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/gd2_im2im.c @@ -0,0 +1,66 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr src, dst; + int r, g, b; + void *p; + int size = 0; + int status = 0; + CuTestImageResult result = {0, 0}; + + src = gdImageCreate(100, 100); + if (src == NULL) { + printf("could not create src\n"); + return 1; + } + r = gdImageColorAllocate(src, 0xFF, 0, 0); + g = gdImageColorAllocate(src, 0, 0xFF, 0); + b = gdImageColorAllocate(src, 0, 0, 0xFF); + gdImageFilledRectangle(src, 0, 0, 99, 99, r); + gdImageRectangle(src, 20, 20, 79, 79, g); + gdImageEllipse(src, 70, 25, 30, 20, b); + +#define OUTPUT_GD2(x) do { \ + FILE *fp; \ + \ + fp = fopen("gd2_im2im_" #x ".gd2", "wb"); \ + if (fp) { \ + gdImageGd2(x, fp, (GD2_CHUNKSIZE_MIN+GD2_CHUNKSIZE_MAX)/2, GD2_FMT_COMPRESSED); \ + fclose(fp); \ + } \ + } while (0) + + OUTPUT_GD2(src); + p = gdImageGd2Ptr(src, (GD2_CHUNKSIZE_MIN+GD2_CHUNKSIZE_MAX)/2, GD2_FMT_COMPRESSED, &size); + if (p == NULL) { + status = 1; + printf("p is null\n"); + goto door0; + } + if (size <= 0) { + status = 1; + printf("size is non-positive\n"); + goto door1; + } + + dst = gdImageCreateFromGd2Ptr(size, p); + if (dst == NULL) { + status = 1; + printf("could not create dst\n"); + goto door1; + } + OUTPUT_GD2(dst); + gdTestImageDiff(src, dst, NULL, &result); + if (result.pixels_changed > 0) { + status = 1; + printf("pixels changed: %d\n", result.pixels_changed); + } + gdImageDestroy(dst); +door1: + gdFree(p); +door0: + gdImageDestroy(src); + return status; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd2/gd2_null.c b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/gd2_null.c new file mode 100644 index 00000000000..6c8fc96caae --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/gd2_null.c @@ -0,0 +1,14 @@ +#include "gd.h" + +int main() +{ + gdImagePtr im; + + im = gdImageCreateFromGd2(NULL); + if (im != NULL) { + gdImageDestroy(im); + return 1; + } + gdImageGd2(im, NULL, 0, GD2_FMT_RAW); /* noop safely */ + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gd2/gd2_read.c b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/gd2_read.c new file mode 100644 index 00000000000..2e78e9a6d23 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gd2/gd2_read.c @@ -0,0 +1,38 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" + +int main() +{ + int error; + gdImagePtr im; + FILE *fp; + char path[1024]; + + sprintf(path, "%s/gd2/conv_test.gd2", GDTEST_TOP_DIR); + + fp = fopen(path, "rb"); + if (!fp) { + printf("failed, cannot open file\n"); + return 1; + } + + im = gdImageCreateFromGd2(fp); + fclose(fp); + + sprintf(path, "%s/gd2/conv_test_exp.png", GDTEST_TOP_DIR); + if (!gdAssertImageEqualsToFile(path, im)) { + error = 1; + gdImageDestroy(im); + } else { + if (im) { + gdImageDestroy(im); + error = 0; + } else { + error = 1; + } + } + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagearc/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagearc/CMakeLists.txt new file mode 100644 index 00000000000..4725daea2cc --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagearc/CMakeLists.txt @@ -0,0 +1,9 @@ +SET(TESTS_FILES + bug00079 +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagearc/bug00079.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagearc/bug00079.c new file mode 100644 index 00000000000..b2843a74873 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagearc/bug00079.c @@ -0,0 +1,25 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int error = 0; + char path[1024]; + + + im = gdImageCreateTrueColor(300, 300); + gdImageFilledRectangle(im, 0,0, 299,299, 0xFFFFFF); + + gdImageSetAntiAliased(im, 0x000000); + gdImageArc(im, 300, 300, 600,600, 0, 360, gdAntiAliased); + + sprintf(path, "%s/gdimagearc/bug00079_exp.png", GDTEST_TOP_DIR); + if (!gdAssertImageEqualsToFile(path, im)) { + printf("%s failed\n", path); + error = 1; + } + + gdImageDestroy(im); + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagearc/bug00079_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagearc/bug00079_exp.png Binary files differnew file mode 100644 index 00000000000..1abfbbfbc51 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagearc/bug00079_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorclosest/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorclosest/CMakeLists.txt new file mode 100644 index 00000000000..30a47c0b800 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorclosest/CMakeLists.txt @@ -0,0 +1,9 @@ +SET(TESTS_FILES + gdimagecolorclosest +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorclosest/gdimagecolorclosest.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorclosest/gdimagecolorclosest.c new file mode 100644 index 00000000000..4754a2c28be --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorclosest/gdimagecolorclosest.c @@ -0,0 +1,59 @@ +#include <stdio.h> +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int error = 0; + int c, i; + + im = gdImageCreateTrueColor(5, 5); + c = gdImageColorClosest(im, 255, 0, 255); + gdImageDestroy(im); + + if (gdTestAssert(c==0xFF00FF) != 1) { + error = -1; + } + + im = gdImageCreate(5, 5); + c = gdImageColorClosest(im, 255, 0, 255); + if (gdTestAssert(c==-1) != 1) { + error = -1; + } + gdImageDestroy(im); + + im = gdImageCreate(5, 5); + c = gdImageColorAllocate(im, 255, 0, 255); + c = gdImageColorClosest(im, 255, 0, 255); + c = gdTrueColorAlpha(gdImageRed(im, c), gdImageGreen(im, c), gdImageBlue(im, c), 0); + gdImageDestroy(im); + if (gdTestAssert(c==0xFF00FF) != 1) { + error = -1; + } + + + im = gdImageCreate(5, 5); + for (i=0; i < 255; i++) { + c = gdImageColorAllocate(im, 255, 0, 0); + } + c = gdImageColorClosest(im, 255, 0, 0); + c = gdTrueColorAlpha(gdImageRed(im, c), gdImageGreen(im, c), gdImageBlue(im, c), 0); + gdImageDestroy(im); + if (gdTestAssert(c==0xFF0000) != 1) { + error = -1; + } + + im = gdImageCreate(5, 5); + for (i=0; i < 256; i++) { + c = gdImageColorAllocate(im, 255, 0, 0); + } + c = gdImageColorClosest(im, 255, 0, 0); + c = gdTrueColorAlpha(gdImageRed(im, c), gdImageGreen(im, c), gdImageBlue(im, c), 0); + gdImageDestroy(im); + if (gdTestAssert(c==0xFF0000) != 1) { + error = -1; + } + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolordeallocate/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolordeallocate/CMakeLists.txt new file mode 100644 index 00000000000..7958cd6cce4 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolordeallocate/CMakeLists.txt @@ -0,0 +1,9 @@ +SET(TESTS_FILES + gdimagecolordeallocate +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolordeallocate/gdimagecolordeallocate.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolordeallocate/gdimagecolordeallocate.c new file mode 100644 index 00000000000..c671bd323de --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolordeallocate/gdimagecolordeallocate.c @@ -0,0 +1,29 @@ +#include <stdio.h> +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int c; + + im = gdImageCreate(1, 1); + /* test for deallocating a color */ + c = gdImageColorAllocate(im, 255, 255, 255); + if (c < 0) { + gdImageDestroy(im); + return 1; + } + gdImageColorDeallocate(im, c); + if (!im->open[c]) { + gdImageDestroy(im); + return 1; + } + + /* just see whether it is OK with out-of-bounds values */ + gdImageColorDeallocate(im, gdMaxColors); + gdImageColorDeallocate(im, -1); + gdImageDestroy(im); + + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorexact/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorexact/CMakeLists.txt new file mode 100644 index 00000000000..f62bc26bbe3 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorexact/CMakeLists.txt @@ -0,0 +1,9 @@ +SET(TESTS_FILES + gdimagecolorexact +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorexact/gdimagecolorexact.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorexact/gdimagecolorexact.c new file mode 100644 index 00000000000..9d754ca9614 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorexact/gdimagecolorexact.c @@ -0,0 +1,64 @@ +#include <stdio.h> +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int error = 0; + int c, c1, c2, c3, c4, color; + + im = gdImageCreateTrueColor(5, 5); + c = gdImageColorExact(im, 255, 0, 255); + c2 = gdImageColorExactAlpha(im, 255, 0, 255, 100); + gdImageDestroy(im); + + if (gdTestAssert(c == 0xFF00FF) != 1) { + error = -1; + } + if (gdTestAssert(c2 == 0x64FF00FF) != 1) { + error = -1; + } + + im = gdImageCreate(5, 5); + c1 = gdImageColorAllocate(im, 255, 0, 255); + c2 = gdImageColorAllocate(im, 255, 200, 0); + c3 = gdImageColorAllocateAlpha(im, 255, 0, 255, 100); + + c1 = gdImageColorExact(im, 255, 0, 255); + c2 = gdImageColorExact(im, 255, 200, 0); + c3 = gdImageColorExactAlpha(im, 255, 0, 255, 100); + c4 = gdImageColorExactAlpha(im, 255, 34, 255, 100); + + if (gdTestAssert(c1 == 0) != 1) { + error = -1; + } + if (gdTestAssert(c2 == 1) != 1) { + error = -1; + } + if (gdTestAssert(c3 == 2) != 1) { + error = -1; + } + if (gdTestAssert(c4 == -1) != 1) { + error = -1; + } + + color = gdTrueColorAlpha(gdImageRed(im, c1), gdImageGreen(im, c1), + gdImageBlue(im, c1), 0); + if (gdTestAssert(color == 0xFF00FF) != 1) { + error = -1; + } + color = gdTrueColorAlpha(gdImageRed(im, c2), gdImageGreen(im, c2), + gdImageBlue(im, c2), 0); + if (gdTestAssert(color == 0xFFC800) != 1) { + error = -1; + } + color = gdTrueColorAlpha(gdImageRed(im, c3), gdImageGreen(im, c3), + gdImageBlue(im, c3), 0); + if (gdTestAssert(color == 0xFF00FF) != 1) { + error = -1; + } + gdImageDestroy(im); + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorreplace/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorreplace/CMakeLists.txt new file mode 100644 index 00000000000..915d9d49873 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorreplace/CMakeLists.txt @@ -0,0 +1,9 @@ +SET(TESTS_FILES + gdimagecolorreplace +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorreplace/gdimagecolorreplace.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorreplace/gdimagecolorreplace.c new file mode 100644 index 00000000000..9694bd4ae5a --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorreplace/gdimagecolorreplace.c @@ -0,0 +1,150 @@ +#include <stdio.h> +#include <limits.h> +#include "gd.h" +#include "gdtest.h" + +static int callback(gdImagePtr im, int src) +{ + int r, g, b; + + r = gdImageRed(im, src); + g = gdImageGreen(im, src); + b = gdImageBlue(im, src); + if (b & 0xFF) { + return gdImageColorResolve(im, 0x0F & r, 0x0F & g, 0); + } else { + return -1; + } +} + +static void run_tests(gdImagePtr im, int *error) +{ + int black, \ + white, \ + cosmic_latte, \ + cream, \ + ivory, \ + magnolia, \ + old_lace, \ + seashell, \ + yellow, \ + c, d; + int src[2], dst[2]; + int n; + +#define COLOR(name, r, g, b) name = gdImageColorAllocateAlpha(im, r, g, b, gdAlphaOpaque) + COLOR(black, 0, 0, 0); + COLOR(white, 0xFF, 0xFF, 0xFF); + COLOR(cosmic_latte, 0xFF, 0xF8, 0xE7); + COLOR(cream, 0xFF, 0xFD, 0xD0); + COLOR(ivory, 0xFF, 0xFF, 0xF0); + COLOR(magnolia, 0xF8, 0xF4, 0xFF); + COLOR(old_lace, 0xFD, 0xF5, 0xE6); + COLOR(seashell, 0xFF, 0xF5, 0xEE); + COLOR(yellow, 0xFF, 0xFF, 0); +#undef COLOR + +#define CHECK_VALUE(n, expected) do { \ + if (gdTestAssert((n) == (expected)) != 1) { \ + printf("%d is expected, but %d\n", expected, n); \ + *error = -1; \ + } \ + } while (0) + +#define CHECK_PIXEL(x, y, expected) do { \ + gdImageSetClip(im, 0, 0, 4, 4); \ + c = gdImageGetPixel(im, (x), (y)); \ + if (gdTestAssert(c == (expected)) != 1) { \ + printf("%d is expected, but %d\n", expected, c); \ + *error = -1; \ + } \ + } while (0) + + c = gdImageColorAllocate(im, 0xFF, 0, 0xFF); + gdImageFilledRectangle(im, 0, 0, 4, 4, white); + gdImageFilledRectangle(im, 0, 0, 3, 3, black); + n = gdImageColorReplace(im, white, c); + CHECK_VALUE(n, 9); + CHECK_PIXEL(0, 0, black); + CHECK_PIXEL(2, 3, black); + CHECK_PIXEL(4, 4, c); + + gdImageSetClip(im, 1, 1, 3, 3); + n = gdImageColorReplace(im, black, c); + CHECK_VALUE(n, 9); + CHECK_PIXEL(0, 0, black); + CHECK_PIXEL(2, 3, c); + + src[0] = black; + src[1] = c; + dst[0] = c; + dst[1] = white; + gdImageSetClip(im, 0, 0, 4, 4); + n = gdImageColorReplaceArray(im, 2, src, dst); + CHECK_VALUE(n, 25); + CHECK_PIXEL(0, 0, c); + CHECK_PIXEL(2, 3, white); + CHECK_PIXEL(4, 4, white); + + n = gdImageColorReplaceArray(im, 0, src, dst); + CHECK_VALUE(n, 0); + n = gdImageColorReplaceArray(im, -1, src, dst); + CHECK_VALUE(n, 0); + n = gdImageColorReplaceArray(im, INT_MAX, src, dst); + CHECK_VALUE(n, -1); + + gdImageSetClip(im, 1, 1, 4, 4); + n = gdImageColorReplaceCallback(im, callback); + CHECK_VALUE(n, 16); + CHECK_PIXEL(0, 0, c); + CHECK_PIXEL(0, 4, white); + d = gdImageColorExact(im, 0x0F, 0x0F, 0); + if (gdTestAssert(d > 0) != 1) { + *error = -1; + } + CHECK_PIXEL(2, 3, d); + CHECK_PIXEL(4, 4, d); + +#define INITIALIZE_IMAGE() \ + gdImageSetClip(im, 0, 0, 4, 4); \ + gdImageFilledRectangle(im, 0, 0, 4, 4, black); \ + gdImageFilledRectangle(im, 1, 1, 3, 3, white); \ + gdImageSetPixel(im, 1, 1, cosmic_latte); \ + gdImageSetPixel(im, 1, 2, cream); \ + gdImageSetPixel(im, 2, 1, ivory); \ + gdImageSetPixel(im, 2, 2, magnolia); \ + gdImageSetPixel(im, 3, 1, old_lace); \ + gdImageSetPixel(im, 3, 2, seashell) + + INITIALIZE_IMAGE(); + n = gdImageColorReplaceThreshold(im, white, yellow, 2.0); + CHECK_VALUE(n, 9); + CHECK_PIXEL(0, 0, black); + CHECK_PIXEL(1, 1, yellow); + CHECK_PIXEL(2, 2, yellow); + CHECK_PIXEL(3, 3, yellow); + +#undef INITIALIZE_IMAGE +#undef CHECK_VALUE +#undef CHECK_PIXEL +} + +int main() +{ + gdImagePtr im; + int error = 0; + + gdSetErrorMethod(gdSilence); + + /* true color */ + im = gdImageCreateTrueColor(5, 5); + run_tests(im, &error); + gdImageDestroy(im); + + /* palette */ + im = gdImageCreate(5, 5); + run_tests(im, &error); + gdImageDestroy(im); + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorresolve/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorresolve/CMakeLists.txt new file mode 100644 index 00000000000..4b918251655 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorresolve/CMakeLists.txt @@ -0,0 +1,9 @@ +SET(TESTS_FILES + gdimagecolorresolve +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorresolve/gdimagecolorresolve.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorresolve/gdimagecolorresolve.c new file mode 100644 index 00000000000..1a0d6884e7e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolorresolve/gdimagecolorresolve.c @@ -0,0 +1,66 @@ +#include <stdio.h> +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int error = 0; + int c, c1, c2, c3, c4, color; + + im = gdImageCreateTrueColor(5, 5); + c = gdImageColorResolve(im, 255, 0, 255); + c2 = gdImageColorResolveAlpha(im, 255, 0, 255, 100); + gdImageDestroy(im); + + if (gdTestAssert(c == 0xFF00FF) != 1) { + error = -1; + } + if (gdTestAssert(c2 == 0x64FF00FF) != 1) { + error = -1; + } + + im = gdImageCreate(5, 5); + + c1 = gdImageColorResolve(im, 255, 0, 255); + c2 = gdImageColorResolve(im, 255, 200, 0); + c3 = gdImageColorResolveAlpha(im, 255, 0, 255, 100); + c4 = gdImageColorResolveAlpha(im, 255, 34, 255, 100); + + if (gdTestAssert(c1 == 0) != 1) { + error = -1; + } + if (gdTestAssert(c2 == 1) != 1) { + error = -1; + } + if (gdTestAssert(c3 == 2) != 1) { + error = -1; + } + if (gdTestAssert(c4 == 3) != 1) { + error = -1; + } + + color = gdTrueColorAlpha(gdImageRed(im, c1), gdImageGreen(im, c1), + gdImageBlue(im, c1), 0); + if (gdTestAssert(color == 0xFF00FF) != 1) { + error = -1; + } + color = gdTrueColorAlpha(gdImageRed(im, c2), gdImageGreen(im, c2), + gdImageBlue(im, c2), 0); + if (gdTestAssert(color == 0xFFC800) != 1) { + error = -1; + } + color = gdTrueColorAlpha(gdImageRed(im, c3), gdImageGreen(im, c3), + gdImageBlue(im, c3), 0); + if (gdTestAssert(color == 0xFF00FF) != 1) { + error = -1; + } + color = gdTrueColorAlpha(gdImageRed(im, c4), gdImageGreen(im, c4), + gdImageBlue(im, c4), 0); + if (gdTestAssert(color == 0xFF22FF) != 1) { + error = -1; + } + gdImageDestroy(im); + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolortransparent/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolortransparent/CMakeLists.txt new file mode 100644 index 00000000000..5f580f7f174 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolortransparent/CMakeLists.txt @@ -0,0 +1,9 @@ +SET(TESTS_FILES + gdimagecolortransparent +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolortransparent/gdimagecolortransparent.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolortransparent/gdimagecolortransparent.c new file mode 100644 index 00000000000..aca380b2c6f --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecolortransparent/gdimagecolortransparent.c @@ -0,0 +1,31 @@ +#include "gd.h" +#include <stdio.h> +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int error = 0, pos; + + pos = gdMaxColors; + + im = gdImageCreate(1,1); + + gdImageColorTransparent(im, pos); + + if(im->transparent == pos) { + error = -1; + } + + pos = -2; + + gdImageColorTransparent(im, pos); + + if(im->transparent == pos) { + error = -1; + } + + gdImageDestroy(im); + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopy/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopy/CMakeLists.txt new file mode 100644 index 00000000000..0b0ccdd77b5 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopy/CMakeLists.txt @@ -0,0 +1,10 @@ +SET(TESTS_FILES + bug00007 + bug00081 +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopy/bug00007.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopy/bug00007.c new file mode 100644 index 00000000000..f3106f3a2f4 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopy/bug00007.c @@ -0,0 +1,30 @@ +#include <stdio.h> +#include <stdlib.h> +#include "gd.h" + +#include "gdtest.h" + +int main() +{ + gdImagePtr dst_tc, src; + int c1; + + src = gdImageCreate(5,5); + gdImageAlphaBlending(src, 0); + + gdImageColorAllocate(src, 255,255,255); /* allocate white for background color */ + c1 = gdImageColorAllocateAlpha(src, 255,0,0,70); + + gdImageFilledRectangle(src, 0,0, 4,4, c1); + + dst_tc = gdImageCreateTrueColor(5,5); + gdImageAlphaBlending(dst_tc, 0); + gdImageCopy(dst_tc, src, 0,0, 0,0, gdImageSX(src), gdImageSY(src)); + + /* CuAssertImageEquals(tc, src, dst_tc); */ + + /* Destroy it */ + gdImageDestroy(dst_tc); + gdImageDestroy(src); + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopy/bug00081.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopy/bug00081.c new file mode 100644 index 00000000000..0e28f4ca409 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopy/bug00081.c @@ -0,0 +1,43 @@ +/* $Id$ */ + +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" + +int main() +{ + gdImagePtr im, im2; + int error = 0; + char path[2048]; + const char *file_exp = "bug00081_exp.png"; + + im = gdImageCreateTrueColor(5, 5); + if (!im) { + printf("can't create the src truecolor image\n"); + return 1; + } + + gdImageFilledRectangle(im, 0, 0, 49, 49, 0x00FFFFFF); + gdImageColorTransparent(im, 0xFFFFFF); + gdImageFilledRectangle(im, 1, 1, 4, 4, 0xFF00FF); + + im2 = gdImageCreateTrueColor(20, 20); + if (!im2) { + printf("can't create the dst truecolor image\n"); + gdImageDestroy(im); + return 1; + } + + gdImageCopy(im2, im, 2, 2 , 0, 0, gdImageSX(im), gdImageSY(im)); + + sprintf(path, "%s/gdimagecopy/%s", GDTEST_TOP_DIR, file_exp); + if (!gdAssertImageEqualsToFile(path, im2)) { + error = 1; + printf("Reference image and destination differ\n"); + } + + gdImageDestroy(im); + gdImageDestroy(im2); + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopy/bug00081_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopy/bug00081_exp.png Binary files differnew file mode 100644 index 00000000000..c5587f78a40 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopy/bug00081_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopyrotated/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopyrotated/CMakeLists.txt new file mode 100644 index 00000000000..7f75aa7c572 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopyrotated/CMakeLists.txt @@ -0,0 +1,10 @@ + +SET(TESTS_FILES + bug00020 +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopyrotated/bug00020.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopyrotated/bug00020.c new file mode 100644 index 00000000000..f1c2467fc47 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopyrotated/bug00020.c @@ -0,0 +1,32 @@ +/* $Id$ */ +#include "gd.h" +#include "gdtest.h" + +#define width 50 + +int main() +{ + gdImagePtr im, im2; + int error = 0; + char path[1024]; + + sprintf(path, "%s/gdimagecopyrotated/bug00020_exp.png", GDTEST_TOP_DIR); + + im = gdImageCreateTrueColor(width, width); + gdImageFilledRectangle(im, 0,0, width, width, 0xFF0000); + gdImageColorTransparent(im, 0xFF0000); + gdImageFilledEllipse(im, width/2, width/2, width - 20, width - 10, + 0x50FFFFFF); + + im2 = gdImageCreateTrueColor(width, width); + + gdImageCopyRotated(im2, im, width / 2, width / 2, 0,0, width, width, 60); + + if (!gdAssertImageEqualsToFile(path, im2)) { + error = 1; + } + + gdImageDestroy(im2); + gdImageDestroy(im); + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopyrotated/bug00020_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopyrotated/bug00020_exp.png Binary files differnew file mode 100644 index 00000000000..f0a9c161b14 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagecopyrotated/bug00020_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefile/gdnametest.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefile/gdnametest.c new file mode 100644 index 00000000000..dd8f0196a59 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefile/gdnametest.c @@ -0,0 +1,169 @@ +#include <stdio.h> +#include <stdlib.h> + +#include "gd.h" +#include "gdtest.h" +#include "../test_config.h" + +#define WIDTH 60 +#define HEIGHT 50 +#define LX (WIDTH/2) // Line X +#define LY (HEIGHT/2) // Line Y +#define HT 2 // Half of line-thickness + + +gdImagePtr mkwhite(int x, int y) +{ + gdImagePtr im; + + im = gdImageCreateTrueColor(x, y); + gdImageFilledRectangle(im, 0, 0, x-1, y-1, + gdImageColorExactAlpha(im, 255, 255, 255, 0)); + + gdTestAssert(im != NULL); + + gdImageSetInterpolationMethod(im, GD_BICUBIC); // FP interp'n + + return im; +}/* mkwhite*/ + + +gdImagePtr mkcross() { + gdImagePtr im; + int fg, n; + + im = mkwhite(WIDTH, HEIGHT); + fg = gdImageColorAllocate(im, 0, 0, 0); + + for (n = -HT; n < HT; n++) { + gdImageLine(im, LX-n, 0, LX-n, HEIGHT-1, fg); + gdImageLine(im, 0, LY-n, WIDTH-1, LY-n, fg); + }/* for */ + + return im; +}/* mkcross*/ + + + + +void +do_test() { + + gdTestAssertMsg(strchr("123",'2') != 0, "strchr() is not functional.\n",1); + gdTestAssertMsg(strcasecmp("123abC","123Abc") == 0, "strcasecmp() is not functional.\n",1); + + int n; + struct { + const char *nm; // Filename + unsigned maxdiff; // Maximum total pixel diff + int required; // 1 -> image type always supported, -1 -> skip it + int readonly; // 1 -> gd can only read this type + } names[] = { + {"img.png", 0, 0, 0}, + {"img.gif", 5, 1, 0}, // This seems to come from tc<->palette + {"img.GIF", 5, 1, 0}, // Test for case insensitivity + {"img.gd", 0, 1, 0}, + {"img.gd2", 0, 0, 0}, + {"img.jpg", 25, 0, 0}, + {"img.jpeg", 25, 0, 0}, + {"img.wbmp", 0, 1, 0}, + {"img.bmp", 0, 1, 0}, + {"img-ref.xpm", 0, 0, 1}, + + // These break the test so I'm skipping them since the point + // of this test is not those loaders. + {"img-ref.xbm", 0, -1, 1}, + {"img-ref.tga", 0, -1, 1}, + {"img.webp", 0, -1, 0}, + {"img.tiff", 0, -1, 0}, + + {NULL, 0} + }; + + for (n = 0; names[n].nm; n++) { + gdImagePtr orig, copy; + int status; + char full_filename[255]; + + /* Some image readers are buggy and crash the program so we + * skip them. Bug fixers should remove these from the list of + * skipped items as bugs are fixed. */ + if (names[n].required < 0) { + printf("Skipping test for '%s'. FIX THIS!\n", names[n].nm); + continue; + }/* if */ + + /* Skip this file if the current library build doesn't support + * it. (If it's one of the built-in types, *that* a different + * problem; we assert that here.) */ + if (!gdSupportsFileType(names[n].nm, 0)) { + gdTestAssertMsg(!names[n].required, "GD doesn't support required file type: %s\n", full_filename); + continue; + }/* if */ + + orig = mkcross(); + + + #ifdef GDTEST_TOP_DIR + + snprintf(full_filename, sizeof(full_filename), GDTEST_TOP_DIR"/gdimagefile/%s", + names[n].nm); + + #else + /* Prepend the test directory; this is expected to be run in + * the parent dir. */ + snprintf(full_filename, sizeof(full_filename), "gdimagefile/%s", + names[n].nm); + #endif + + + /* Write the image unless writing is not supported. */ + if (!names[n].readonly) { + status = gdImageFile(orig, full_filename); + gdTestAssertMsg(status == GD_TRUE, "Failed to create %s\n", full_filename); + }/* if */ + + copy = gdImageCreateFromFile(full_filename); + gdTestAssertMsg(!!copy, "Failed to load %s\n", full_filename); + if (!copy) continue; + + /* Debug printf. */ + //printf("%s -> %d\n", full_filename, gdMaxPixelDiff(orig, copy)); + + gdTestAssertMsg(gdMaxPixelDiff(orig, copy) <= names[n].maxdiff,"Pixels different on %s\n", full_filename, full_filename); + + if (!names[n].readonly) { + status = remove(full_filename); + gdTestAssertMsg(status == 0, "Failed to delete %s\n", full_filename); + }/* if */ + + gdImageDestroy(orig); + gdImageDestroy(copy); + }/* for */ + +}/* do_test*/ + + +void +do_errortest() { + gdImagePtr im; + + im = mkcross(); + + gdTestAssert(!gdImageFile(im, "img.xpng")); + gdTestAssert(!gdImageFile(im, "bobo")); + gdTestAssert(!gdImageFile(im, "png")); + gdTestAssert(!gdImageFile(im, "")); + + gdImageDestroy(im); +}/* do_errortest*/ + + +int main(int argc, char **argv) +{ + + do_test(); + do_errortest(); + + return gdNumFailures(); +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefile/img-ref.tga b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefile/img-ref.tga Binary files differnew file mode 100644 index 00000000000..201e1450760 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefile/img-ref.tga diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefile/img-ref.xbm b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefile/img-ref.xbm new file mode 100644 index 00000000000..bb7ebb72c40 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefile/img-ref.xbm @@ -0,0 +1,37 @@ +#define foo-ref_width 60 +#define foo-ref_height 50 +static char foo-ref_bits[] = { + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, + 0x01, 0x00, 0x00, 0x00, }; diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefile/img-ref.xpm b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefile/img-ref.xpm new file mode 100644 index 00000000000..574d3d95d2d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefile/img-ref.xpm @@ -0,0 +1,58 @@ +/* XPM */ +static char *img_ref[] = { +/* columns rows colors chars-per-pixel */ +"60 50 2 1 ", +" c gray100", +". c black", +/* pixels */ +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +"............................................................", +"............................................................", +"............................................................", +"............................................................", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... ", +" .... " +}; diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/CMakeLists.txt new file mode 100644 index 00000000000..ef85f1cf7ef --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/CMakeLists.txt @@ -0,0 +1,12 @@ + +SET(TESTS_FILES + bug00002_1 + bug00002_2 + bug00002_3 + bug00002_4 +) +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_1.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_1.c new file mode 100644 index 00000000000..2a440f20ede --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_1.c @@ -0,0 +1,48 @@ +#include "gd.h" +#include <stdio.h> +#include "gdtest.h" + +#define TMP_FN "bug00002_1.png" + +int main() +{ + gdImagePtr im; + FILE *fp; + char path[1024]; + + im = gdImageCreateTrueColor(100, 100); + + if (im == NULL) { + gdTestErrorMsg("Cannot create image.\n"); + return 1; + } + + gdImageFill(im, 0, 0, 0xffffff); + gdImageFill(im, 0, 0, 0xffffff); + + fp = fopen(TMP_FN, "wb"); + if (fp == NULL) { + gdTestErrorMsg("Cannot create image from <%s>\n", TMP_FN); + gdImageDestroy(im); + return 1; + } + + gdImagePng(im,fp); + fclose(fp); + + sprintf(path, "%s/gdimagefill/bug00002_1_exp.png", GDTEST_TOP_DIR); + if (!gdAssertImageEqualsToFile(path, im)) { + gdImageDestroy(im); + return 1; + } + + gdImageDestroy(im); + + if (remove(TMP_FN) == -1) { + gdTestErrorMsg("Cannot remove temporary file: <%s>\n", TMP_FN); + return 1; + } + + return 0; +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_1_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_1_exp.png Binary files differnew file mode 100644 index 00000000000..a5435f278bc --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_1_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_2.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_2.c new file mode 100644 index 00000000000..06cf8311195 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_2.c @@ -0,0 +1,50 @@ +#include "gd.h" +#include <stdio.h> +#include "gdtest.h" + +int main() +{ + gdImagePtr im, tile; + int im_black, tile_black; + int x,y, error = 0; + char path[1024]; + +/* fputs("flag 0\n", stdout); */ + im = gdImageCreate(150, 150); + tile = gdImageCreate(36, 36); + gdImageColorAllocate(tile,255,255,255); /* allocate white for background color */ + tile_black = gdImageColorAllocate(tile,0,0,0); + gdImageColorAllocate(im,255,255,255); /* allocate white for background color */ + im_black = gdImageColorAllocate(im,0,0,0); + + + /* create the dots pattern */ + for (x=0; x<36; x+=2) { + for (y=0; y<36; y+=2) { + gdImageSetPixel(tile,x,y,tile_black); + } + } + + gdImageSetTile(im,tile); + gdImageRectangle(im, 9,9,139,139, im_black); + gdImageLine(im, 9,9,139,139, im_black); + gdImageFill(im, 11,12, gdTiled); + + +/* fputs("flag 1\n", stdout); */ + gdImageFill(im, 0, 0, 0xffffff); +/* fputs("flag 2\n", stdout); */ + gdImageFill(im, 0, 0, 0xffffff); +/* fputs("flag 2\n", stdout); */ + + + sprintf(path, "%s/gdimagefill/bug00002_2_exp.png", GDTEST_TOP_DIR); + if (!gdAssertImageEqualsToFile(path, im)) { + error = 1; + } + + /* Destroy it */ + gdImageDestroy(im); + return error; +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_2_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_2_exp.png Binary files differnew file mode 100644 index 00000000000..2a3f0fb2c65 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_2_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_3.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_3.c new file mode 100644 index 00000000000..454d5be3612 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_3.c @@ -0,0 +1,56 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include "gdtest.h" + +int main() +{ + gdImagePtr im, tile; + int im_black, tile_white, tile_black; + int x,y, error = 0; + char path[1024]; + +/* fputs("flag 0\n", stdout); */ + im = gdImageCreate(150, 150); + + + tile = gdImageCreateTrueColor(36, 36); + + tile_white = gdImageColorAllocate(tile,255,255,255); + tile_black = gdImageColorAllocate(tile,55,0,0); + gdImageColorAllocate(im,255,255,255); /* allocate white for background color */ + im_black = gdImageColorAllocate(im,0,0,0); + + gdImageFill(tile, 0,0, tile_white); + gdImageColorTransparent(tile, tile_black); + gdImageColorTransparent(im, im_black); + + /* create the dots pattern */ + for (x=0; x<36; x+=2) { + for (y=0; y<36; y+=2) { + gdImageSetPixel(tile,x,y,tile_black); + } + } + + gdImageSetTile(im,tile); + gdImageRectangle(im, 9,9,139,139, im_black); + gdImageLine(im, 9,9,139,139, im_black); + gdImageFill(im, 11,12, gdTiled); + + +/* fputs("flag 1\n", stdout); */ + gdImageFill(im, 0, 0, 0xffffff); +/* fputs("flag 2\n", stdout); */ + gdImageFill(im, 0, 0, 0xffffff); +/* fputs("flag 3\n", stdout); */ + + sprintf(path, "%s/gdimagefill/bug00002_3_exp.png", GDTEST_TOP_DIR); + if (!gdAssertImageEqualsToFile(path, im)) { + error = 1; + } + + /* Destroy it */ + gdImageDestroy(im); + return error; +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_3_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_3_exp.png Binary files differnew file mode 100644 index 00000000000..b8b7a2b319d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_3_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_4.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_4.c new file mode 100644 index 00000000000..4b11d84bdc9 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_4.c @@ -0,0 +1,40 @@ +/*ImageFill Pattern fill */ + +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int red, blue, white, black, error = 0; + char path[1024]; + + im = gdImageCreate(50,100); + red = gdImageColorAllocate(im, 255, 0, 0); + blue = gdImageColorAllocate(im, 0,0,255); + white = gdImageColorAllocate(im, 255,255,255); + black = gdImageColorAllocate(im, 0,0,0); + gdImageFill(im, 0,0, black); + + gdImageLine(im, 20,20,180,20, white); + gdImageLine(im, 20,20,20,70, blue); + gdImageLine(im, 20,70,180,70, red); + gdImageLine(im, 180,20,180,45, white); + gdImageLine(im, 180,70,180,45, red); + gdImageLine(im, 20,20,100,45, blue); + gdImageLine(im, 20,70,100,45, blue); + gdImageLine(im, 100,45,180,45, red); + + gdImageFill(im, 21,45, blue); + gdImageFill(im, 100,69, red); + gdImageFill(im, 100,21, white); + + sprintf(path, "%s/gdimagefill/bug00002_4_exp.png", GDTEST_TOP_DIR); + if (!gdAssertImageEqualsToFile(path, im)) { + error = 1; + } + + /* Destroy it */ + gdImageDestroy(im); + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_4_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_4_exp.png Binary files differnew file mode 100644 index 00000000000..d751a74d7a0 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefill/bug00002_4_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/CMakeLists.txt new file mode 100644 index 00000000000..fb1ed6ca1ac --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/CMakeLists.txt @@ -0,0 +1,11 @@ + +SET(TESTS_FILES + bug00010 + bug00191 +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/bug00010.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/bug00010.c new file mode 100644 index 00000000000..df0c66dbc64 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/bug00010.c @@ -0,0 +1,21 @@ +/* $Id$ */ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int error = 0; + char path[1024]; + + im = gdImageCreateTrueColor(100,100); + gdImageFilledEllipse(im, 50,50, 70, 90, 0x50FFFFFF); + + sprintf(path, "%s/gdimagefilledellipse/bug00010_exp.png", GDTEST_TOP_DIR); + if (!gdAssertImageEqualsToFile(path, im)) { + error = 1; + } + + gdImageDestroy(im); + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/bug00010_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/bug00010_exp.png Binary files differnew file mode 100644 index 00000000000..871ca671987 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/bug00010_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/bug00191.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/bug00191.c new file mode 100644 index 00000000000..7db64151726 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/bug00191.c @@ -0,0 +1,21 @@ +/* $Id$ */ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int error = 0; + char path[1024]; + + im = gdImageCreate(100, 100); + (void)gdImageColorAllocate(im, 255, 255, 255); + gdImageSetThickness(im, 20); + gdImageFilledEllipse(im, 30, 50, 20, 20, gdImageColorAllocate(im, 0, 0, 0)); + sprintf(path, "%s/gdimagefilledellipse/bug00191.png", GDTEST_TOP_DIR); + if (!gdAssertImageEqualsToFile(path, im)) { + error = 1; + } + gdImageDestroy(im); + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/bug00191.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/bug00191.png Binary files differnew file mode 100644 index 00000000000..dbb7439e2b5 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledellipse/bug00191.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/CMakeLists.txt new file mode 100644 index 00000000000..2ca4bf51f99 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/CMakeLists.txt @@ -0,0 +1,13 @@ +SET(TESTS_FILES + gdimagefilledpolygon0 + gdimagefilledpolygon1 + gdimagefilledpolygon2 + gdimagefilledpolygon3 + bug00100 +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/bug00100.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/bug00100.c new file mode 100644 index 00000000000..ae2e084fe41 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/bug00100.c @@ -0,0 +1,157 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdtest.h" + +/* This is a quickie test program to show a bug in gd. + * There is a red line that is drawn across the bottom of + * the image that shouldn't be there. + */ +int +main(void) +{ + gdPoint pointy[5]; + gdPoint diamond[4]; + int d, x, y, top, bot, left, right, r; + + /* R G B */ + int white = gdTrueColorAlpha(255, 255, 255, 10); + int black = gdTrueColorAlpha( 0, 0, 0, 10); + int red = gdTrueColorAlpha(255, 0, 0, 10); + int green = gdTrueColorAlpha( 0, 255, 0, 10); + int blue = gdTrueColorAlpha( 0, 0, 255, 10); + int yellow = gdTrueColorAlpha(255, 255, 0, 10); + int cyan = gdTrueColorAlpha( 0, 255, 255, 10); + int magenta = gdTrueColorAlpha(255, 0, 255, 10); + int purple = gdTrueColorAlpha(100, 0, 100, 10); + + gdImagePtr im = gdImageCreateTrueColor(256, 256); + if (!im) exit(EXIT_FAILURE); + + gdImageFilledRectangle(im, 0, 0, 256, 256, white); + + /* M (bridge) */ + top = 240; + bot = 255; + d = 30; + x = 100; + pointy[0].x = x; + pointy[0].y = top; + pointy[1].x = x+2*d; + pointy[1].y = top; + pointy[2].x = x+2*d; + pointy[2].y = bot; + pointy[3].x = x+d; + pointy[3].y = (top+bot)/2; + pointy[4].x = x; + pointy[4].y = bot; + gdImageFilledPolygon(im, pointy, 5, yellow); + + /* left-facing M not on baseline */ + top = 40; + bot = 70; + left = 120; + right = 180; + pointy[0].x = left; + pointy[0].y = top; + pointy[1].x = right; + pointy[1].y = top; + pointy[2].x = right; + pointy[2].y = bot; + pointy[3].x = left; + pointy[3].y = bot; + pointy[4].x = (left+right)/2; + pointy[4].y = (top+bot)/2; + gdImageFilledPolygon(im, pointy, 5, purple); + + /* left-facing M on baseline */ + top = 240; + bot = 270; + left = 20; + right = 80; + pointy[0].x = left; + pointy[0].y = top; + pointy[1].x = right; + pointy[1].y = top; + pointy[2].x = right; + pointy[2].y = bot; + pointy[3].x = left; + pointy[3].y = bot; + pointy[4].x = (left+right)/2; + pointy[4].y = (top+bot)/2; + gdImageFilledPolygon(im, pointy, 5, magenta); + + /* left-facing M on ceiling */ + top = -15; + bot = 15; + left = 20; + right = 80; + pointy[0].x = left; + pointy[0].y = top; + pointy[1].x = right; + pointy[1].y = top; + pointy[2].x = right; + pointy[2].y = bot; + pointy[3].x = left; + pointy[3].y = bot; + pointy[4].x = (left+right)/2; + pointy[4].y = (top+bot)/2; + gdImageFilledPolygon(im, pointy, 5, blue); + + d = 30; + x = 150; + y = 150; + diamond[0].x = x-d; + diamond[0].y = y; + diamond[1].x = x; + diamond[1].y = y+d; + diamond[2].x = x+d; + diamond[2].y = y; + diamond[3].x = x; + diamond[3].y = y-d; + gdImageFilledPolygon(im, diamond, 4, green); + + x = 180; + y = 225; + diamond[0].x = x-d; + diamond[0].y = y; + diamond[1].x = x; + diamond[1].y = y+d; + diamond[2].x = x+d; + diamond[2].y = y; + diamond[3].x = x; + diamond[3].y = y-d; + gdImageFilledPolygon(im, diamond, 4, red); + + x = 225; + y = 255; + diamond[0].x = x-d; + diamond[0].y = y; + diamond[1].x = x; + diamond[1].y = y+d; + diamond[2].x = x+d; + diamond[2].y = y; + diamond[3].x = x; + diamond[3].y = y-d; + gdImageFilledPolygon(im, diamond, 4, cyan); + + /* M (bridge) not touching bottom boundary */ + top = 100; + bot = 150; + x = 30; + pointy[0].x = x; + pointy[0].y = top; + pointy[1].x = x+2*d; + pointy[1].y = top; + pointy[2].x = x+2*d; + pointy[2].y = bot; + pointy[3].x = x+d; + pointy[3].y = (top+bot)/2; + pointy[4].x = x; + pointy[4].y = bot; + gdImageFilledPolygon(im, pointy, 5, black); + + r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimagefilledpolygon/bug00100.png", im); + gdImageDestroy(im); + if (!r) exit(EXIT_FAILURE); + return EXIT_SUCCESS; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/bug00100.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/bug00100.png Binary files differnew file mode 100644 index 00000000000..439224e2334 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/bug00100.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon0.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon0.c new file mode 100644 index 00000000000..5ca877c630c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon0.c @@ -0,0 +1,22 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + int white, black, r; + + im = gdImageCreate(100, 100); + if (!im) exit(EXIT_FAILURE); + white = gdImageColorAllocate(im, 0xff, 0xff, 0xff); + black = gdImageColorAllocate(im, 0, 0, 0); + gdImageFilledRectangle(im, 0, 0, 99, 99, white); + gdImageFilledPolygon(im, NULL, 0, black); /* no effect */ + gdImageFilledPolygon(im, NULL, -1, black); /* no effect */ + r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimagefilledpolygon/gdimagefilledpolygon0.png", im); + gdImageDestroy(im); + if (!r) exit(EXIT_FAILURE); + return EXIT_SUCCESS; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon0.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon0.png Binary files differnew file mode 100644 index 00000000000..14c7090a415 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon0.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon1.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon1.c new file mode 100644 index 00000000000..950035e2b4b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon1.c @@ -0,0 +1,31 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + int white, black, r; + gdPointPtr points; + + im = gdImageCreate(100, 100); + if (!im) exit(EXIT_FAILURE); + white = gdImageColorAllocate(im, 0xff, 0xff, 0xff); + black = gdImageColorAllocate(im, 0, 0, 0); + gdImageFilledRectangle(im, 0, 0, 99, 99, white); + points = (gdPointPtr)calloc(3, sizeof(gdPoint)); + if (!points) { + gdImageDestroy(im); + exit(EXIT_FAILURE); + } + points[0].x = 10; + points[0].y = 10; + gdImageFilledPolygon(im, points, 1, black); + r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimagefilledpolygon/gdimagefilledpolygon1.png", im); + free(points); + gdImageDestroy(im); + if (!r) exit(EXIT_FAILURE); + return EXIT_SUCCESS; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon1.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon1.png Binary files differnew file mode 100644 index 00000000000..14c7090a415 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon1.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon2.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon2.c new file mode 100644 index 00000000000..628665a1919 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon2.c @@ -0,0 +1,33 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + int white, black, r; + gdPointPtr points; + + im = gdImageCreate(100, 100); + if (!im) exit(EXIT_FAILURE); + white = gdImageColorAllocate(im, 0xff, 0xff, 0xff); + black = gdImageColorAllocate(im, 0, 0, 0); + gdImageFilledRectangle(im, 0, 0, 99, 99, white); + points = (gdPointPtr)calloc(3, sizeof(gdPoint)); + if (!points) { + gdImageDestroy(im); + exit(EXIT_FAILURE); + } + points[0].x = 10; + points[0].y = 10; + points[1].x = 50; + points[1].y = 70; + gdImageFilledPolygon(im, points, 2, black); + r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimagefilledpolygon/gdimagefilledpolygon2.png", im); + free(points); + gdImageDestroy(im); + if (!r) exit(EXIT_FAILURE); + return EXIT_SUCCESS; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon2.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon2.png Binary files differnew file mode 100644 index 00000000000..80f91a2814b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon2.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon3.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon3.c new file mode 100644 index 00000000000..0db5c8519e1 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon3.c @@ -0,0 +1,35 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + int white, black, r; + gdPointPtr points; + + im = gdImageCreate(100, 100); + if (!im) exit(EXIT_FAILURE); + white = gdImageColorAllocate(im, 0xff, 0xff, 0xff); + black = gdImageColorAllocate(im, 0, 0, 0); + gdImageFilledRectangle(im, 0, 0, 99, 99, white); + points = (gdPointPtr)calloc(3, sizeof(gdPoint)); + if (!points) { + gdImageDestroy(im); + exit(EXIT_FAILURE); + } + points[0].x = 10; + points[0].y = 10; + points[1].x = 50; + points[1].y = 70; + points[2].x = 90; + points[2].y = 30; + gdImageFilledPolygon(im, points, 3, black); + r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimagefilledpolygon/gdimagefilledpolygon3.png", im); + free(points); + gdImageDestroy(im); + if (!r) exit(EXIT_FAILURE); + return EXIT_SUCCESS; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon3.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon3.png Binary files differnew file mode 100644 index 00000000000..72311d83a29 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledpolygon/gdimagefilledpolygon3.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledrectangle/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledrectangle/CMakeLists.txt new file mode 100644 index 00000000000..73920709bb5 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledrectangle/CMakeLists.txt @@ -0,0 +1,11 @@ +SET(TESTS_FILES + bug00004 + bug00078 + bug00106_gdimagefilledrectangle +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledrectangle/bug00004.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledrectangle/bug00004.c new file mode 100644 index 00000000000..594e29637d7 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledrectangle/bug00004.c @@ -0,0 +1,27 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int c1,c2,c3,c4,c5; + + im = gdImageCreateTrueColor(100,100); + gdImageFilledRectangle(im, 2,2, 80,95, 0x50FFFFFF); + + c1 = gdImageGetTrueColorPixel(im, 2, 2); + c2 = gdImageGetTrueColorPixel(im, 80, 95); + c3 = gdImageGetTrueColorPixel(im, 80, 2); + c4 = gdImageGetTrueColorPixel(im, 2, 95); + c5 = gdImageGetTrueColorPixel(im, 49, 49); + + gdImageDestroy(im); + if (0x005e5e5e == c1 && 0x005e5e5e == c2 && + 0x005e5e5e == c3 && 0x005e5e5e == c4 && + 0x005e5e5e == c5) { + return 0; + } else { + return 1; + } +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledrectangle/bug00078.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledrectangle/bug00078.c new file mode 100644 index 00000000000..adf244ebca2 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledrectangle/bug00078.c @@ -0,0 +1,39 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int c1,c2,c3,c4,c5; + + im = gdImageCreateTrueColor(100,100); + gdImageFilledRectangle(im, 2,2, 80,95, 0x50FFFFFF); + c1 = gdImageGetTrueColorPixel(im, 2, 2); + c2 = gdImageGetTrueColorPixel(im, 80, 95); + c3 = gdImageGetTrueColorPixel(im, 80, 2); + c4 = gdImageGetTrueColorPixel(im, 2, 95); + c5 = gdImageGetTrueColorPixel(im, 49, 49); + + if (!(0x005e5e5e == c1 && 0x005e5e5e == c2 && + 0x005e5e5e == c3 && 0x005e5e5e == c4)) { + return 1; + } + gdImageFilledRectangle(im, 0, 0, 99, 99, 0x0); + + gdImageFilledRectangle(im, 80,95, 2,2, 0x50FFFFFF); + c1 = gdImageGetTrueColorPixel(im, 2, 2); + c2 = gdImageGetTrueColorPixel(im, 80, 95); + c3 = gdImageGetTrueColorPixel(im, 80, 2); + c4 = gdImageGetTrueColorPixel(im, 2, 95); + c5 = gdImageGetTrueColorPixel(im, 49, 49); + + if (!(0x005e5e5e == c1 && 0x005e5e5e == c2 && + 0x005e5e5e == c3 && 0x005e5e5e == c4 && + 0x005e5e5e == c5)) { + return 1; + } + + gdImageDestroy(im); + return 0; +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledrectangle/bug00106_gdimagefilledrectangle.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledrectangle/bug00106_gdimagefilledrectangle.c new file mode 100644 index 00000000000..24f5ceb9327 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilledrectangle/bug00106_gdimagefilledrectangle.c @@ -0,0 +1,27 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int c1,c2,c3,c4; + + im = gdImageCreateTrueColor(10,10); + if (!im) { + return 1; + } + + gdImageFilledRectangle(im, 1,1, 1,1, 0x50FFFFFF); + c1 = gdImageGetTrueColorPixel(im, 1, 1); + c2 = gdImageGetTrueColorPixel(im, 2, 1); + c3 = gdImageGetTrueColorPixel(im, 1, 2); + c4 = gdImageGetTrueColorPixel(im, 2, 2); + gdImageDestroy(im); + if (0x005e5e5e == c1 && 0x0 == c2 && + 0x0 == c3 && 0x0 == c4) { + return 0; + } else { + return 1; + } +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilltoborder/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilltoborder/CMakeLists.txt new file mode 100644 index 00000000000..e24a69a1452 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilltoborder/CMakeLists.txt @@ -0,0 +1,9 @@ + +SET(TESTS_FILES + bug00037 +) +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilltoborder/bug00037.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilltoborder/bug00037.c new file mode 100644 index 00000000000..646adbd0f79 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilltoborder/bug00037.c @@ -0,0 +1,30 @@ +#include <stdio.h> +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int bordercolor, color; + + im = gdImageCreateTrueColor(100, 100); + + gdImageAlphaBlending(im, 1); + gdImageSaveAlpha(im, 1); + bordercolor = gdImageColorAllocateAlpha(im, 0, 0, 0, 2); + color = gdImageColorAllocateAlpha(im, 0, 0, 0, 1); + + gdImageFillToBorder(im, 5, 5, bordercolor, color); + + color = gdImageGetPixel(im, 5, 5); + + gdImageDestroy(im); + if (gdTestAssert(color==0x1000000)) { + return 0; + } else { + printf("c: %X, expected %X\n", color, 0x1000000); + return -1; + } + +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilter/gdCopyBlurred.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilter/gdCopyBlurred.c new file mode 100644 index 00000000000..69ca06133bc --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagefilter/gdCopyBlurred.c @@ -0,0 +1,198 @@ +#include <stdio.h> +#include <stdlib.h> + +#include "gd.h" +#include "gdtest.h" + +#define WIDTH 300 +#define HEIGHT 200 +#define LX (WIDTH/2) // Line X +#define LY (HEIGHT/2) // Line Y +#define HT 3 // Half of line-thickness + +#define CLOSE_ENOUGH 0 +#define PIXEL_CLOSE_ENOUGH 0 + + +void +save(gdImagePtr im, const char *filename) { +#if 0 // set TRUE to write out some intermediate images + FILE *out; + + out = fopen(filename, "wb"); + gdImagePng(im, out); + fclose(out); +#else + im, filename; +#endif +}/* save*/ + + +/* Test gdImageScale() with bicubic interpolation on a simple + * all-white image. */ + +gdImagePtr mkwhite(int x, int y) +{ + gdImagePtr im; + + im = gdImageCreateTrueColor(x, y); + gdImageFilledRectangle(im, 0, 0, x-1, y-1, + gdImageColorExactAlpha(im, 255, 255, 255, 0)); + + gdTestAssert(im != NULL); + + gdImageSetInterpolationMethod(im, GD_BICUBIC); // FP interp'n + + return im; +}/* mkwhite*/ + + +/* Fill with almost-black. */ +void mkblack(gdImagePtr ptr) +{ + gdImageFilledRectangle(ptr, 0, 0, ptr->sx - 1, ptr->sy - 1, + gdImageColorExactAlpha(ptr, 2, 2, 2, 0)); +}/* mkblack*/ + + +gdImagePtr mkcross() { + gdImagePtr im; + int fg, n; + + im = mkwhite(WIDTH, HEIGHT); + fg = gdImageColorAllocate(im, 0, 0, 0); + + for (n = -HT; n < HT; n++) { + gdImageLine(im, LX-n, 0, LX-n, HEIGHT-1, fg); + gdImageLine(im, 0, LY-n, WIDTH-1, LY-n, fg); + }/* for */ + + return im; +}/* mkcross*/ + + + +void blurblank(gdImagePtr im, int radius, double sigma) { + gdImagePtr result; + + result = gdImageCopyGaussianBlurred(im, radius, sigma); + gdTestAssert(!!result); + if (!result) return; + + gdTestAssert(gdMaxPixelDiff(im, result) <= CLOSE_ENOUGH); + + gdImageDestroy(result); +}/* blurblank*/ + + +void do_test() +{ + gdImagePtr im, imref, tmp; + gdImagePtr same, same2; + + im = mkwhite(WIDTH, HEIGHT); + imref = mkwhite(WIDTH, HEIGHT); + + /* Blur a plain white image to various radii and ensure they're + * still similar enough. */ + blurblank(im, 1, 0.0); + blurblank(im, 2, 0.0); + blurblank(im, 4, 0.0); + blurblank(im, 8, 0.0); + blurblank(im, 16, 0.0); + + /* Ditto a black image. */ + mkblack(im); + gdTestAssert(gdMaxPixelDiff(im, imref) >= 240); /* Leaves a little wiggle room */ + + blurblank(im, 1, 0.0); + blurblank(im, 2, 0.0); + blurblank(im, 4, 0.0); + blurblank(im, 8, 0.0); + blurblank(im, 16, 0.0); +}/* do_test*/ + +/* Ensure that RGB values are equal, then return r (which is therefore + * the whiteness.) */ +int getwhite(gdImagePtr im, int x, int y) +{ + int px, r, g, b; + + px = gdImageGetPixel(im, x, y); + r = gdImageRed(im, px); + g = gdImageGreen(im, px); + b = gdImageBlue(im, px); + + gdTestAssert(r == g && r == b); + + return r; +}/* getrgb*/ + +int whitecmp(gdImagePtr im1, gdImagePtr im2, int x, int y) { + int w1, w2; + + w1 = getwhite(im1, x, y); + w2 = getwhite(im2, x, y); + + return abs(w1 - w2); +}/* whitediff*/ + +void do_crosstest() +{ + gdImagePtr im = mkcross(); + gdImagePtr blurred; + const int RADIUS = 16; + + gdTestAssert(!!im); + + save(im, "cross.png"); + + blurred = gdImageCopyGaussianBlurred(im, RADIUS, 0.0); + gdTestAssert(blurred != NULL); + save(blurred, "blurredcross.png"); + + /* These spots shouldn't be affected. */ + gdTestAssert(whitecmp(im, blurred, 5, 5) <= PIXEL_CLOSE_ENOUGH); + gdTestAssert(whitecmp(im, blurred, WIDTH-5, 5) <= PIXEL_CLOSE_ENOUGH); + gdTestAssert(whitecmp(im, blurred, 5, HEIGHT-5) <= PIXEL_CLOSE_ENOUGH); + gdTestAssert(whitecmp(im, blurred, WIDTH-5, HEIGHT-5) <= PIXEL_CLOSE_ENOUGH); + +// printf("%d %d %d %d\n", whitecmp(im, blurred, 0, 0), whitecmp(im, blurred, WIDTH-1, 0), +// whitecmp(im, blurred, 0, HEIGHT-1), whitecmp(im, blurred, WIDTH-1, HEIGHT-1)); + + /* Ditto these, right in the corners */ + gdTestAssert(whitecmp(im, blurred, 0, 0) <= PIXEL_CLOSE_ENOUGH); + gdTestAssert(whitecmp(im, blurred, WIDTH-1, 0) <= PIXEL_CLOSE_ENOUGH); + gdTestAssert(whitecmp(im, blurred, 0, HEIGHT-1) <= PIXEL_CLOSE_ENOUGH); + gdTestAssert(whitecmp(im, blurred, WIDTH-1, HEIGHT-1) <= PIXEL_CLOSE_ENOUGH); + + /* Now, poking let's poke around the blurred lines. */ + + /* Vertical line gets darker when approached from the left. */ + gdTestAssert(getwhite(blurred, 1, 1) > getwhite(blurred, LX - (HT - 1), 1)); + gdTestAssert(getwhite(blurred, LX - 2, 1) > getwhite(blurred, LX - 1, 1)); + + /* ...and lighter when moving away to the right. */ + gdTestAssert(getwhite(blurred, LX + 2, 1) >= getwhite(blurred, LX + 1, 1)); + gdTestAssert(getwhite(blurred, LX + 3, 1) >= getwhite(blurred, LX + 2, 1)); + gdTestAssert(getwhite(blurred, WIDTH - 1, 1) > getwhite(blurred, LX + 1, 1)); + + /* And the same way, vertically */ + gdTestAssert(getwhite(blurred, 1, 1) > getwhite(blurred, 1, LY - (HT - 1))); + gdTestAssert(getwhite(blurred, 1, LY - (HT - 1)) > getwhite(blurred, 1, LY - (HT - 2))); + + gdTestAssert(getwhite(blurred, 1, LY) <= getwhite(blurred, 1, LY + 1)); + gdTestAssert(getwhite(blurred, 1, LY + 1) < getwhite(blurred, 1, LY + 3)); + gdTestAssert(getwhite(blurred, 1, LY + 3) < getwhite(blurred, 1, HEIGHT-1)); + gdImageDestroy(blurred); +}/* do_crosstest*/ + + +int main(int argc, char **argv) +{ + + do_test(); + do_crosstest(); + + return gdNumFailures(); +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/CMakeLists.txt new file mode 100644 index 00000000000..78f11d424fb --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/CMakeLists.txt @@ -0,0 +1,13 @@ +SET(TESTS_FILES + gdimageline_aa + gdimageline_aa_outofrange + bug00077 + bug00072 + bug00111 +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00072.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00072.c new file mode 100644 index 00000000000..c3a3137e539 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00072.c @@ -0,0 +1,35 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + const char *exp = "bug00072_exp.png"; + int error = 0; + + char path[1024]; + + + im = gdImageCreateTrueColor(11, 11); + gdImageFilledRectangle(im, 0, 0, 10, 10, 0xFFFFFF); + gdImageSetThickness(im, 3); + + gdImageLine(im, 5, 0, 5, 11, 0x000000); + gdImageLine(im, 0, 5, 11, 5, 0x000000); + gdImageLine(im, 0, 0, 11, 11, 0x000000); + + gdImageSetThickness(im, 1); + + gdImageLine(im, 5, 0, 5, 11, 0xFF0000); + gdImageLine(im, 0, 5, 11, 5, 0xFF0000); + gdImageLine(im, 0, 0, 11, 11, 0xFF0000); + + sprintf(path, "%s/gdimageline/%s", GDTEST_TOP_DIR, exp); + if (!gdAssertImageEqualsToFile(path, im)) { + error = 1; + } + + gdImageDestroy(im); + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00072_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00072_exp.png Binary files differnew file mode 100644 index 00000000000..6439e061f1d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00072_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00077.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00077.c new file mode 100644 index 00000000000..d69e88177f2 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00077.c @@ -0,0 +1,31 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + const char *exp = "bug00077_exp.png"; + int error = 0; + + char path[1024]; + + + im = gdImageCreateTrueColor(11, 11); + gdImageFilledRectangle(im, 0, 0, 10, 10, 0xFFFFFF); + gdImageSetThickness(im, 1); + + gdImageLine(im, 0, 10, 0, 0, 0x0); + gdImageLine(im, 5, 10, 5, 0, 0x0); + gdImageLine(im, 10, 5, 0, 5, 0x0); + gdImageLine(im, 10, 10, 0, 10, 0x0); + + sprintf(path, "%s/gdimageline/%s", GDTEST_TOP_DIR, exp); + + if (!gdAssertImageEqualsToFile(path, im)) { + error = 1; + } + + gdImageDestroy(im); + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00077_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00077_exp.png Binary files differnew file mode 100644 index 00000000000..bfa097a5c56 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00077_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00111.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00111.c new file mode 100644 index 00000000000..4277534874d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00111.c @@ -0,0 +1,35 @@ +/* $Id$ */ + +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int error = 0; + char path[2048]; + const char *file_exp = "bug00111_exp.png"; + + im = gdImageCreateTrueColor(10, 10); + if (!im) { + printf("can't get truecolor image\n"); + return 1; + } + + gdImageLine(im, 2, 2, 2, 2, 0xFFFFFF); + gdImageLine(im, 5, 5, 5, 5, 0xFFFFFF); + + gdImageLine(im, 0, 0, 0, 0, 0xFFFFFF); + + sprintf(path, "%s/gdimageline/%s", GDTEST_TOP_DIR, file_exp); + if (!gdAssertImageEqualsToFile(path, im)) { + error = 1; + printf("Reference image and destination differ\n"); + } + + gdImageDestroy(im); + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00111_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00111_exp.png Binary files differnew file mode 100644 index 00000000000..ecd44b25d66 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/bug00111_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdImageAALine_thickness.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdImageAALine_thickness.c new file mode 100644 index 00000000000..954e055b6fb --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdImageAALine_thickness.c @@ -0,0 +1,30 @@ +#include <stdio.h> +#include "gd.h" +#include "gdtest.h" + +int main(int argc, char **argv) +{ + gdImagePtr im; + char path[2048]; + const char *file_exp = "gdimageline/gdImageAALine_thickness_exp.png"; + + im = gdImageCreateTrueColor(100, 100); + gdImageFilledRectangle(im, 0, 0, 99, 99, + gdImageColorExactAlpha(im, 255, 255, 255, 0)); + + gdImageSetThickness(im, 5); + gdImageSetAntiAliased(im, gdImageColorExactAlpha(im, 0, 0, 0, 0)); + gdImageLine(im, 0,0, 99, 99, gdAntiAliased); + + sprintf(path, "%s/%s", GDTEST_TOP_DIR, file_exp); + + if (!gdAssertImageEqualsToFile(path, im)) { + printf("comparing rotated image to %s failed.\n", path); + gdImageDestroy(im); + return 1; + } + + gdImageDestroy(im); + + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdImageAALine_thickness_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdImageAALine_thickness_exp.png Binary files differnew file mode 100644 index 00000000000..26e02bc3661 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdImageAALine_thickness_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa.c new file mode 100644 index 00000000000..b0bea3a4d5c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa.c @@ -0,0 +1,76 @@ +#include <stdio.h> +#include <math.h> +#include "gd.h" +#include "gdtest.h" + +#ifdef _MSC_VER +# define snprintf _snprintf +#endif + +int gen_image(const char* filename, int idx, int reverse_x, int width, int height, int bgd) +{ + double gradient = height / (width*2.0); + int offset = idx*width; + int x1,y1,x2,y2, error = 0; + + gdImagePtr im = gdImageCreateTrueColor(width,height); + if (bgd==1) { + gdImageFilledRectangle(im,0,0,width-1,height-1, gdTrueColorAlpha(255, 255, 255, 0)); + } else { + gdImageFilledRectangle(im,0,0,width-1,height-1, gdTrueColorAlpha(255, 255, 0, 0)); + } + + gdImageSetAntiAliased(im, gdTrueColorAlpha(0,0,0,0)); + + /* + test for potential segfault (introduced with AA improvements, fixed + with the same patch - but I didn't notice it until later).*/ + gdImageLine(im,-1,-1,-1,-1,gdAntiAliased); + + x1 = floor(reverse_x * -width + 0.5); + y1 = (offset-width) * gradient + 0.5; + + x2 = floor(reverse_x * width*2 + 0.5); + y2 = floor((offset+width*2) * gradient + 0.5); + + /* draw an AA line */ + gdImageLine(im, x1, y1, x2, y2, gdAntiAliased); + + gdImageLine(im, 0, im->sy - 1, im->sx, im->sy - 1, 0x40FF0000); + + if (!gdAssertImageEqualsToFile(filename, im)) { + gdTestErrorMsg("gdAssertImageEqualsToFile failed: <%s>\n", filename); + error = 1; + } + gdImageDestroy(im); + return error; +} + +int main() +{ + int error = 0; + char path[1024]; + + snprintf(path, sizeof(path)-1, "%s/gdimageline/gdimageline_aa_a_0_exp.png", GDTEST_TOP_DIR); + error |= gen_image(path,0,1,10,100, 1); + + snprintf(path, sizeof(path)-1, "%s/gdimageline/gdimageline_aa_a_1_exp.png", GDTEST_TOP_DIR); + error |= gen_image(path,1,1,10,100, 2); + + snprintf(path, sizeof(path)-1, "%s/gdimageline/gdimageline_aa_b_0_exp.png", GDTEST_TOP_DIR); + error |= gen_image(path,2,-1,10,100, 1); + snprintf(path, sizeof(path)-1, "%s/gdimageline/gdimageline_aa_b_1_exp.png", GDTEST_TOP_DIR); + error |= gen_image(path,1,-1,10,100, 2); + + snprintf(path, sizeof(path)-1, "%s/gdimageline/gdimageline_aa_c_0_exp.png", GDTEST_TOP_DIR); + error |= gen_image(path,0,1,100,10, 1); + snprintf(path, sizeof(path)-1, "%s/gdimageline/gdimageline_aa_c_1_exp.png", GDTEST_TOP_DIR); + error |= gen_image(path,1,1,100,10, 2); + + snprintf(path, sizeof(path)-1, "%s/gdimageline/gdimageline_aa_d_0_exp.png", GDTEST_TOP_DIR); + error |= gen_image(path,2,-1,100,10, 1); + snprintf(path, sizeof(path)-1, "%s/gdimageline/gdimageline_aa_d_1_exp.png", GDTEST_TOP_DIR); + error |= gen_image(path,1,-1,100,10, 2); + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_a_0_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_a_0_exp.png Binary files differnew file mode 100644 index 00000000000..83f893453ed --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_a_0_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_a_1_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_a_1_exp.png Binary files differnew file mode 100644 index 00000000000..c4edcfa36ec --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_a_1_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_b_0_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_b_0_exp.png Binary files differnew file mode 100644 index 00000000000..130d6c36cc7 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_b_0_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_b_1_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_b_1_exp.png Binary files differnew file mode 100644 index 00000000000..678800658d3 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_b_1_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_c_0_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_c_0_exp.png Binary files differnew file mode 100644 index 00000000000..6d03ae6652e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_c_0_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_c_1_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_c_1_exp.png Binary files differnew file mode 100644 index 00000000000..6e1a38aa7e1 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_c_1_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_d_0_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_d_0_exp.png Binary files differnew file mode 100644 index 00000000000..c6f9e27e4fc --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_d_0_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_d_1_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_d_1_exp.png Binary files differnew file mode 100644 index 00000000000..709c186c26a --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_d_1_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_outofrange.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_outofrange.c new file mode 100644 index 00000000000..5c1ed05ab03 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_aa_outofrange.c @@ -0,0 +1,19 @@ +#include <stdio.h> +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + + im = gdImageCreateTrueColor(300, 300); + + gdImageSetAntiAliased(im, gdTrueColorAlpha(255, 255, 255, 0)); + + gdImageLine(im, -1, -1, -1, -1, gdAntiAliased); + gdImageLine(im, 299, 299, 0, 299, gdAntiAliased); + gdImageLine(im, 1,1, 50, 50, gdAntiAliased); + + /* Test for segfaults, if we reach this point, the test worked */ + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_bug5.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_bug5.c new file mode 100644 index 00000000000..44adc8eaf86 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageline/gdimageline_bug5.c @@ -0,0 +1,54 @@ +#include <stdio.h> +#include "gd.h" +#include "gdtest.h" + +int main() { + /* Declare the image */ + gdImagePtr im, ref; + + /* Declare output files */ + /* FILE *pngout; */ + int black, white; + + im = gdImageCreateTrueColor(63318, 771); + + /* Allocate the color white (red, green and blue all maximum). */ + white = gdImageColorAllocate(im, 255, 255, 255); + /* Allocate the color white (red, green and blue all maximum). */ + black = gdImageColorAllocate(im, 0, 0, 0); + + /* white background */ + gdImageFill(im, 1, 1, white); + + /* Make a reference copy. */ + ref = gdImageClone(im); + + gdImageSetAntiAliased(im, black); + + /* This line used to fail. */ + gdImageLine(im, 28562, 631, 34266, 750, gdAntiAliased); + + gdTestAssert(gdMaxPixelDiff(im, ref) > 0); + +#if 0 + { + FILE *pngout; + + /* Open a file for writing. "wb" means "write binary", + * important under MSDOS, harmless under Unix. */ + pngout = fopen("test.png", "wb"); + + /* Output the image to the disk file in PNG format. */ + gdImagePng(im, pngout); + + /* Close the files. */ + fclose(pngout); + } +#endif + + /* Destroy the image in memory. */ + gdImageDestroy(im); + gdImageDestroy(ref); + + return gdNumFailures(); +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/CMakeLists.txt new file mode 100644 index 00000000000..4e54fffb143 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/CMakeLists.txt @@ -0,0 +1,12 @@ +SET(TESTS_FILES + gdimageopenpolygon0 + gdimageopenpolygon1 + gdimageopenpolygon2 + gdimageopenpolygon3 +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon0.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon0.c new file mode 100644 index 00000000000..d9bf1bd962a --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon0.c @@ -0,0 +1,22 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + int white, black, r; + + im = gdImageCreate(100, 100); + if (!im) exit(EXIT_FAILURE); + white = gdImageColorAllocate(im, 0xff, 0xff, 0xff); + black = gdImageColorAllocate(im, 0, 0, 0); + gdImageFilledRectangle(im, 0, 0, 99, 99, white); + gdImageOpenPolygon(im, NULL, 0, black); /* no effect */ + gdImageOpenPolygon(im, NULL, -1, black); /* no effect */ + r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimageopenpolygon/gdimageopenpolygon0.png", im); + gdImageDestroy(im); + if (!r) exit(EXIT_FAILURE); + return EXIT_SUCCESS; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon0.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon0.png Binary files differnew file mode 100644 index 00000000000..14c7090a415 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon0.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon1.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon1.c new file mode 100644 index 00000000000..07ee29dff49 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon1.c @@ -0,0 +1,31 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + int white, black, r; + gdPointPtr points; + + im = gdImageCreate(100, 100); + if (!im) exit(EXIT_FAILURE); + white = gdImageColorAllocate(im, 0xff, 0xff, 0xff); + black = gdImageColorAllocate(im, 0, 0, 0); + gdImageFilledRectangle(im, 0, 0, 99, 99, white); + points = (gdPointPtr)calloc(3, sizeof(gdPoint)); + if (!points) { + gdImageDestroy(im); + exit(EXIT_FAILURE); + } + points[0].x = 10; + points[0].y = 10; + gdImageOpenPolygon(im, points, 1, black); + r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimageopenpolygon/gdimageopenpolygon1.png", im); + free(points); + gdImageDestroy(im); + if (!r) exit(EXIT_FAILURE); + return EXIT_SUCCESS; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon1.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon1.png Binary files differnew file mode 100644 index 00000000000..14c7090a415 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon1.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon2.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon2.c new file mode 100644 index 00000000000..ab097d83cad --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon2.c @@ -0,0 +1,33 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + int white, black, r; + gdPointPtr points; + + im = gdImageCreate(100, 100); + if (!im) exit(EXIT_FAILURE); + white = gdImageColorAllocate(im, 0xff, 0xff, 0xff); + black = gdImageColorAllocate(im, 0, 0, 0); + gdImageFilledRectangle(im, 0, 0, 99, 99, white); + points = (gdPointPtr)calloc(3, sizeof(gdPoint)); + if (!points) { + gdImageDestroy(im); + exit(EXIT_FAILURE); + } + points[0].x = 10; + points[0].y = 10; + points[1].x = 50; + points[1].y = 70; + gdImageOpenPolygon(im, points, 2, black); + r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimageopenpolygon/gdimageopenpolygon2.png", im); + free(points); + gdImageDestroy(im); + if (!r) exit(EXIT_FAILURE); + return EXIT_SUCCESS; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon2.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon2.png Binary files differnew file mode 100644 index 00000000000..80f91a2814b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon2.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon3.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon3.c new file mode 100644 index 00000000000..027bfacd20b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon3.c @@ -0,0 +1,35 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + int white, black, r; + gdPointPtr points; + + im = gdImageCreate(100, 100); + if (!im) exit(EXIT_FAILURE); + white = gdImageColorAllocate(im, 0xff, 0xff, 0xff); + black = gdImageColorAllocate(im, 0, 0, 0); + gdImageFilledRectangle(im, 0, 0, 99, 99, white); + points = (gdPointPtr)calloc(3, sizeof(gdPoint)); + if (!points) { + gdImageDestroy(im); + exit(EXIT_FAILURE); + } + points[0].x = 10; + points[0].y = 10; + points[1].x = 50; + points[1].y = 70; + points[2].x = 90; + points[2].y = 30; + gdImageOpenPolygon(im, points, 3, black); + r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimageopenpolygon/gdimageopenpolygon3.png", im); + free(points); + gdImageDestroy(im); + if (!r) exit(EXIT_FAILURE); + return EXIT_SUCCESS; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon3.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon3.png Binary files differnew file mode 100644 index 00000000000..9d63d6ac9ba --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimageopenpolygon/gdimageopenpolygon3.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepixelate/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepixelate/CMakeLists.txt new file mode 100644 index 00000000000..2d10b21ed94 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepixelate/CMakeLists.txt @@ -0,0 +1,9 @@ +SET(TESTS_FILES + gdimagepixelate +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepixelate/gdimagepixelate.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepixelate/gdimagepixelate.c new file mode 100644 index 00000000000..2a0a4692269 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepixelate/gdimagepixelate.c @@ -0,0 +1,88 @@ +#include "gd.h" +#include "gdtest.h" + +#define WIDTH 12 +#define BLOCK_SIZE 4 + +static const int expected_upperleft[][3] = { + {0x000000, 0x040404, 0x080808}, + {0x303030, 0x343434, 0x383838}, + {0x606060, 0x646464, 0x686868} +}; + +static const int expected_average[][3] = { + {0x131313, 0x171717, 0x1b1b1b}, + {0x434343, 0x474747, 0x4b4b4b}, + {0x737373, 0x777777, 0x7b7b7b}, +}; + +#define SETUP_PIXELS(im) do { \ + int x, y, i = 0; \ + for (y = 0; y < (im)->sy; y++) { \ + for (x = 0; x < (im)->sx; x++) { \ + int p = gdImageColorResolve(im, i, i, i); \ + gdImageSetPixel(im, x, y, p); \ + i++; \ + } \ + } \ + } while (0) + +#define CHECK_PIXELS(im, expected) do { \ + int x, y; \ + for (y = 0; y < (im)->sy; y++) { \ + for (x = 0; x < (im)->sx; x++) { \ + int p = gdImageGetPixel(im, x, y); \ + int r = ((expected)[y/BLOCK_SIZE][x/BLOCK_SIZE]>>16)&0xFF; \ + int g = ((expected)[y/BLOCK_SIZE][x/BLOCK_SIZE]>> 8)&0xFF; \ + int b = ((expected)[y/BLOCK_SIZE][x/BLOCK_SIZE] )&0xFF; \ + if (r != gdImageRed(im, p)) { \ + printf("Red %x is expected, but %x\n", r, gdImageRed(im, p)); \ + return 0; \ + } \ + if (g != gdImageGreen(im, p)) { \ + printf("Green %x is expected, but %x\n", g, gdImageGreen(im, p)); \ + return 0; \ + } \ + if (b != gdImageBlue(im, p)) { \ + printf("Blue %x is expected, but %x\n", b, gdImageBlue(im, p)); \ + return 0; \ + } \ + } \ + } \ + } while (0) + +static int testPixelate(gdImagePtr im) +{ + if (gdImagePixelate(im, -1, GD_PIXELATE_UPPERLEFT) != 0) return 0; + if (gdImagePixelate(im, 1, GD_PIXELATE_UPPERLEFT) != 1) return 0; + if (gdImagePixelate(im, 2, -1) != 0) return 0; + + SETUP_PIXELS(im); + if (!gdImagePixelate(im, BLOCK_SIZE, GD_PIXELATE_UPPERLEFT)) return 0; + CHECK_PIXELS(im, expected_upperleft); + + SETUP_PIXELS(im); + if (!gdImagePixelate(im, BLOCK_SIZE, GD_PIXELATE_AVERAGE)) return 0; + CHECK_PIXELS(im, expected_average); + + return 1; +} + +int main() +{ + gdImagePtr im; + + im = gdImageCreate(WIDTH, WIDTH); + if (!testPixelate(im)) { + return 1; + } + gdImageDestroy(im); + + im = gdImageCreateTrueColor(WIDTH, WIDTH); + if (!testPixelate(im)) { + return 2; + } + gdImageDestroy(im); + + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/CMakeLists.txt new file mode 100644 index 00000000000..679e93986be --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/CMakeLists.txt @@ -0,0 +1,12 @@ +SET(TESTS_FILES + gdimagepolygon0 + gdimagepolygon1 + gdimagepolygon2 + gdimagepolygon3 +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon0.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon0.c new file mode 100644 index 00000000000..20fa423c056 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon0.c @@ -0,0 +1,22 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + int white, black, r; + + im = gdImageCreate(100, 100); + if (!im) exit(EXIT_FAILURE); + white = gdImageColorAllocate(im, 0xff, 0xff, 0xff); + black = gdImageColorAllocate(im, 0, 0, 0); + gdImageFilledRectangle(im, 0, 0, 99, 99, white); + gdImagePolygon(im, NULL, 0, black); /* no effect */ + gdImagePolygon(im, NULL, -1, black); /* no effect */ + r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimagepolygon/gdimagepolygon0.png", im); + gdImageDestroy(im); + if (!r) exit(EXIT_FAILURE); + return EXIT_SUCCESS; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon0.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon0.png Binary files differnew file mode 100644 index 00000000000..14c7090a415 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon0.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon1.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon1.c new file mode 100644 index 00000000000..6f2ad57dfcc --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon1.c @@ -0,0 +1,31 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + int white, black, r; + gdPointPtr points; + + im = gdImageCreate(100, 100); + if (!im) exit(EXIT_FAILURE); + white = gdImageColorAllocate(im, 0xff, 0xff, 0xff); + black = gdImageColorAllocate(im, 0, 0, 0); + gdImageFilledRectangle(im, 0, 0, 99, 99, white); + points = (gdPointPtr)calloc(3, sizeof(gdPoint)); + if (!points) { + gdImageDestroy(im); + exit(EXIT_FAILURE); + } + points[0].x = 10; + points[0].y = 10; + gdImagePolygon(im, points, 1, black); + r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimagepolygon/gdimagepolygon1.png", im); + free(points); + gdImageDestroy(im); + if (!r) exit(EXIT_FAILURE); + return EXIT_SUCCESS; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon1.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon1.png Binary files differnew file mode 100644 index 00000000000..845c5f6930b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon1.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon2.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon2.c new file mode 100644 index 00000000000..8142c3ba873 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon2.c @@ -0,0 +1,33 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + int white, black, r; + gdPointPtr points; + + im = gdImageCreate(100, 100); + if (!im) exit(EXIT_FAILURE); + white = gdImageColorAllocate(im, 0xff, 0xff, 0xff); + black = gdImageColorAllocate(im, 0, 0, 0); + gdImageFilledRectangle(im, 0, 0, 99, 99, white); + points = (gdPointPtr)calloc(3, sizeof(gdPoint)); + if (!points) { + gdImageDestroy(im); + exit(EXIT_FAILURE); + } + points[0].x = 10; + points[0].y = 10; + points[1].x = 50; + points[1].y = 70; + gdImagePolygon(im, points, 2, black); + r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimagepolygon/gdimagepolygon2.png", im); + free(points); + gdImageDestroy(im); + if (!r) exit(EXIT_FAILURE); + return EXIT_SUCCESS; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon2.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon2.png Binary files differnew file mode 100644 index 00000000000..80f91a2814b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon2.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon3.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon3.c new file mode 100644 index 00000000000..55d71f27a9c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon3.c @@ -0,0 +1,35 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + int white, black, r; + gdPointPtr points; + + im = gdImageCreate(100, 100); + if (!im) exit(EXIT_FAILURE); + white = gdImageColorAllocate(im, 0xff, 0xff, 0xff); + black = gdImageColorAllocate(im, 0, 0, 0); + gdImageFilledRectangle(im, 0, 0, 99, 99, white); + points = (gdPointPtr)calloc(3, sizeof(gdPoint)); + if (!points) { + gdImageDestroy(im); + exit(EXIT_FAILURE); + } + points[0].x = 10; + points[0].y = 10; + points[1].x = 50; + points[1].y = 70; + points[2].x = 90; + points[2].y = 30; + gdImagePolygon(im, points, 3, black); + r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimagepolygon/gdimagepolygon3.png", im); + free(points); + gdImageDestroy(im); + if (!r) exit(EXIT_FAILURE); + return EXIT_SUCCESS; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon3.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon3.png Binary files differnew file mode 100644 index 00000000000..aaff882a8fb --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagepolygon/gdimagepolygon3.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerectangle/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerectangle/CMakeLists.txt new file mode 100644 index 00000000000..2c73ef9b77a --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerectangle/CMakeLists.txt @@ -0,0 +1,10 @@ +SET(TESTS_FILES + bug00003 + bug00106_gdimagerectangle +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerectangle/bug00003.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerectangle/bug00003.c new file mode 100644 index 00000000000..4ee4ddbcb5d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerectangle/bug00003.c @@ -0,0 +1,23 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int c1,c2,c3,c4; + + im = gdImageCreateTrueColor(100,100); + gdImageRectangle(im, 2,2, 80,95, 0x50FFFFFF); + c1 = gdImageGetTrueColorPixel(im, 2, 2); + c2 = gdImageGetTrueColorPixel(im, 80, 95); + c3 = gdImageGetTrueColorPixel(im, 80, 2); + c4 = gdImageGetTrueColorPixel(im, 2, 95); + + gdImageDestroy(im); + if (0x005e5e5e == c1 && 0x005e5e5e == c2 && + 0x005e5e5e == c3 && 0x005e5e5e == c4) { + return 0; + } else { + return 1; + } +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerectangle/bug00106_gdimagerectangle.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerectangle/bug00106_gdimagerectangle.c new file mode 100644 index 00000000000..21bf88b7440 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerectangle/bug00106_gdimagerectangle.c @@ -0,0 +1,28 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + int c1,c2,c3,c4; + + im = gdImageCreateTrueColor(10,10); + + if (!im) { + return 1; + } + + gdImageRectangle(im, 1,1, 1,1, 0x50FFFFFF); + c1 = gdImageGetTrueColorPixel(im, 1, 1); + c2 = gdImageGetTrueColorPixel(im, 2, 1); + c3 = gdImageGetTrueColorPixel(im, 1, 2); + c4 = gdImageGetTrueColorPixel(im, 2, 2); + gdImageDestroy(im); + + if (0x005e5e5e == c1 && 0x0 == c2 && + 0x0 == c3 && 0x0 == c4) { + return 0; + } else { + return 1; + } +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067.c new file mode 100644 index 00000000000..4a6595988b9 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067.c @@ -0,0 +1,67 @@ +#include <stdio.h> +#include <stdlib.h> +#include "gd.h" + +#include "gdtest.h" + +int main() +{ + gdImagePtr im, exp; + char path[2048]; + const char *file_im = "gdimagerotate/remirh128.jpg"; + const char *file_exp = "gdimagerotate/bug00067"; + FILE *fp; + int color; + int error = 0; + int angle; + + sprintf(path, "%s/%s", GDTEST_TOP_DIR, file_im); + + fp = fopen(path, "rb"); + + if (!fp) { + gdTestErrorMsg("opening Jpeg %s for reading failed.\n", path); + return 1; + } + + im = gdImageCreateFromJpeg(fp); + + fclose(fp); + + if (!im) { + gdTestErrorMsg("loading %s failed.\n", path); + return 1; + } + + color = gdImageColorAllocate(im, 0, 0, 0); + + if (color < 0) { + gdTestErrorMsg("allocation color from image failed.\n"); + gdImageDestroy(im); + return 1; + } + + for (angle = 0; angle <= 180; angle += 15) { + + exp = gdImageRotateInterpolated(im, angle, color); + + if (!exp) { + gdTestErrorMsg("rotating image failed for %03d.\n", angle); + gdImageDestroy(im); + return 1; + } + + sprintf(path, "%s/%s_%03d_exp.png", GDTEST_TOP_DIR, file_exp, angle); + + if (!gdAssertImageEqualsToFile(path, exp)) { + gdTestErrorMsg("comparing rotated image to %s failed.\n", path); + error += 1; + } + + gdImageDestroy(exp); + } + + gdImageDestroy(im); + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_000_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_000_exp.png Binary files differnew file mode 100644 index 00000000000..d06b5fe58fb --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_000_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_015_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_015_exp.png Binary files differnew file mode 100644 index 00000000000..a0f8ce2efae --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_015_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_030_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_030_exp.png Binary files differnew file mode 100644 index 00000000000..aad7f4ccb67 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_030_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_045_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_045_exp.png Binary files differnew file mode 100644 index 00000000000..75916a51649 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_045_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_060_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_060_exp.png Binary files differnew file mode 100644 index 00000000000..f24364a062f --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_060_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_075_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_075_exp.png Binary files differnew file mode 100644 index 00000000000..f8dcf449086 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_075_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_090_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_090_exp.png Binary files differnew file mode 100644 index 00000000000..a971447c7b2 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_090_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_105_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_105_exp.png Binary files differnew file mode 100644 index 00000000000..2cf641d85a8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_105_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_120_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_120_exp.png Binary files differnew file mode 100644 index 00000000000..1890f92545c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_120_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_135_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_135_exp.png Binary files differnew file mode 100644 index 00000000000..34ccb0aa054 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_135_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_150_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_150_exp.png Binary files differnew file mode 100644 index 00000000000..330d030a7fa --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_150_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_165_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_165_exp.png Binary files differnew file mode 100644 index 00000000000..df5b6400bc2 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_165_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_180_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_180_exp.png Binary files differnew file mode 100644 index 00000000000..d4f65983615 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/bug00067_180_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/php_bug_64898.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/php_bug_64898.c new file mode 100644 index 00000000000..9bbd98b5313 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/php_bug_64898.c @@ -0,0 +1,58 @@ +#include <stdio.h> +#include <stdlib.h> +#include "gd.h" + +#include "gdtest.h" + +int main() +{ + gdImagePtr im, exp; + char path[2048]; + const char *file_im = "gdimagerotate/php_bug_64898.png"; + const char *file_exp = "gdimagerotate/php_bug_64898_exp.png"; + FILE *fp; + int color; + + sprintf(path, "%s/%s", GDTEST_TOP_DIR, file_im); + + fp = fopen(path, "rb"); + + if (!fp) { + gdTestErrorMsg("opening PNG %s for reading failed.\n", path); + return 1; + } + + im = gdImageCreateTrueColor(141, 200); + + if (!im) { + gdTestErrorMsg("loading %s failed.\n", path); + return 1; + } + + gdImageFilledRectangle(im, 0, 0, 140, 199, 0x00ffffff); + +/* Try default interpolation method, but any non-optimized fails */ +/* gdImageSetInterpolationMethod(im, GD_BICUBIC_FIXED); */ + + exp = gdImageRotateInterpolated(im, 45, 0x0); + + if (!exp) { + gdTestErrorMsg("rotating image failed.\n"); + gdImageDestroy(im); + return 1; + } + + sprintf(path, "%s/%s", GDTEST_TOP_DIR, file_exp); + + if (!gdAssertImageEqualsToFile(path, exp)) { + printf("comparing rotated image to %s failed.\n", path); + gdImageDestroy(im); + gdImageDestroy(exp); + return 1; + } + + gdImageDestroy(exp); + gdImageDestroy(im); + + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/php_bug_64898.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/php_bug_64898.png Binary files differnew file mode 100644 index 00000000000..089680a248c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/php_bug_64898.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/php_bug_64898_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/php_bug_64898_exp.png Binary files differnew file mode 100644 index 00000000000..a03bdb8e9d6 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/php_bug_64898_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/remirh128.jpg b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/remirh128.jpg Binary files differnew file mode 100644 index 00000000000..bd5e3c77e3c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagerotate/remirh128.jpg diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/CMakeLists.txt new file mode 100644 index 00000000000..13de90a4ff6 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/CMakeLists.txt @@ -0,0 +1,10 @@ +SET(TESTS_FILES + bug00208_1 + bug00208_2 +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208.png Binary files differnew file mode 100644 index 00000000000..eac854aeaeb --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208_1.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208_1.c new file mode 100644 index 00000000000..4dc8b63e737 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208_1.c @@ -0,0 +1,55 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im, ex; + FILE *fp; + gdScatter s; + CuTestImageResult r; + + fp = fopen(GDTEST_TOP_DIR "/gdimagescatterex/bug00208.png", "rb"); + if (!fp) { + fprintf(stderr, "could not open file\n"); + return 1; + } + im = gdImageCreateFromPng(fp); + fclose(fp); + if (!im) { + fprintf(stderr, "could not create image\n"); + return 1; + } + + s.sub = 1; + s.plus = 3; + s.seed = 0; + s.num_colors = 0; + if (!gdImageScatterEx(im, &s)) { + gdImageDestroy(im); + fprintf(stderr, "could not scatter\n"); + return 1; + } + + fp = fopen(GDTEST_TOP_DIR "/gdimagescatterex/bug00208_1.png", "rb"); + if (!fp) { + fprintf(stderr, "could not open file\n"); + gdImageDestroy(im); + return 1; + } + ex = gdImageCreateFromPng(fp); + fclose(fp); + if (!ex) { + fprintf(stderr, "could not create image\n"); + gdImageDestroy(im); + return 1; + } + r.pixels_changed = 0; + gdTestImageDiff(im, ex, NULL, &r); + gdImageDestroy(ex); + gdImageDestroy(im); + if (r.pixels_changed > 10000) { + fprintf(stderr, "too much diff: %d\n", r.pixels_changed); + return 1; + } + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208_1.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208_1.png Binary files differnew file mode 100644 index 00000000000..21ef1240db4 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208_1.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208_2.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208_2.c new file mode 100644 index 00000000000..90361569df2 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208_2.c @@ -0,0 +1,57 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im, ex; + FILE *fp; + gdScatter s; + int colors[] = {0xFF0000, 0x00FF00}; + CuTestImageResult r; + + fp = fopen(GDTEST_TOP_DIR "/gdimagescatterex/bug00208.png", "rb"); + if (!fp) { + fprintf(stderr, "could not open file\n"); + return 1; + } + im = gdImageCreateFromPng(fp); + fclose(fp); + if (!im) { + fprintf(stderr, "could not create image\n"); + return 1; + } + + s.sub = 1; + s.plus = 3; + s.seed = 0; + s.num_colors = 2; + s.colors = colors; + if (!gdImageScatterEx(im, &s)) { + gdImageDestroy(im); + fprintf(stderr, "could not scatter\n"); + return 1; + } + + fp = fopen(GDTEST_TOP_DIR "/gdimagescatterex/bug00208_2.png", "rb"); + if (!fp) { + fprintf(stderr, "could not open file\n"); + gdImageDestroy(im); + return 1; + } + ex = gdImageCreateFromPng(fp); + fclose(fp); + if (!ex) { + fprintf(stderr, "could not create image\n"); + gdImageDestroy(im); + return 1; + } + r.pixels_changed = 0; + gdTestImageDiff(im, ex, NULL, &r); + gdImageDestroy(ex); + gdImageDestroy(im); + if (r.pixels_changed > 10000) { + fprintf(stderr, "too much diff: %d\n", r.pixels_changed); + return 1; + } + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208_2.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208_2.png Binary files differnew file mode 100644 index 00000000000..feb1ede3594 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagescatterex/bug00208_2.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagesetpixel/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagesetpixel/CMakeLists.txt new file mode 100644 index 00000000000..1fb1f38bb36 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagesetpixel/CMakeLists.txt @@ -0,0 +1,11 @@ +SET(TESTS_FILES + bug00186 + gdeffectoverlay + gdeffectmultiply +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagesetpixel/bug00186.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagesetpixel/bug00186.c new file mode 100644 index 00000000000..efa07b27ec8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagesetpixel/bug00186.c @@ -0,0 +1,32 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + gdImagePtr tile; + int red, green, blue, other; + int i, r = 0; + + im = gdImageCreateTrueColor(100, 100); + tile = gdImageCreate(10, 10); + red = gdImageColorAllocate(tile, 0xFF, 0, 0); + green = gdImageColorAllocate(tile, 0, 0xFF, 0); + blue = gdImageColorAllocate(tile, 0, 0, 0xFF); + other = gdImageColorAllocate(tile, 0, 0, 0x2); + gdImageFilledRectangle(tile, 0, 0, 2, 10, red); + gdImageFilledRectangle(tile, 3, 0, 4, 10, green); + gdImageFilledRectangle(tile, 5, 0, 7, 10, blue); + gdImageFilledRectangle(tile, 8, 0, 9, 10, other); + gdImageColorTransparent(tile, blue); + gdImageSetTile(im, tile); + for (i=0; i<100; i++) { + gdImageSetPixel(im, i, i, gdTiled); + } + if (gdTrueColorGetBlue(gdImageGetPixel(im, 9, 9)) != 0x2) { + r = 1; + } + gdImageDestroy(tile); + gdImageDestroy(im); + return r; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagestringft/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagestringft/CMakeLists.txt new file mode 100644 index 00000000000..c3338c0dc92 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagestringft/CMakeLists.txt @@ -0,0 +1,9 @@ +SET(TESTS_FILES + gdimagestringft_bbox +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagestringft/gdimagestringft_bbox.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagestringft/gdimagestringft_bbox.c new file mode 100644 index 00000000000..01fd73a33c1 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagestringft/gdimagestringft_bbox.c @@ -0,0 +1,81 @@ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include "gdtest.h" + +#define PI 3.141592 +#define DELTA (PI/8) + +static int EXPECT[16][8] = { + {498, 401, 630, 401, 630, 374, 498, 374}, + {491, 364, 613, 313, 602, 288, 481, 338}, + {470, 332, 563, 239, 544, 219, 451, 312}, + {438, 310, 488, 189, 463, 178, 412, 300}, + {401, 303, 401, 171, 374, 171, 374, 303}, + {365, 310, 314, 188, 289, 199, 339, 320}, + {334, 331, 241, 238, 221, 257, 314, 350}, + {313, 362, 192, 312, 181, 337, 303, 388}, + {306, 398, 174, 398, 174, 425, 306, 425}, + {313, 433, 191, 484, 202, 509, 323, 459}, + {333, 463, 240, 556, 259, 576, 352, 483}, + {363, 484, 313, 605, 338, 616, 389, 494}, + {398, 490, 398, 622, 425, 622, 425, 490}, + {432, 483, 483, 605, 508, 594, 458, 473}, + {461, 464, 554, 557, 574, 538, 481, 445}, + {481, 435, 602, 485, 613, 460, 491, 409}, +}; + +int main() +{ + char path[2048]; + gdImagePtr im; + int black; + double cos_t, sin_t; + int x, y, temp; + int i, j; + int brect[8]; + int error = 0; + FILE *fp; + + sprintf(path, "%s/freetype/DejaVuSans.ttf", GDTEST_TOP_DIR); + im = gdImageCreate(800, 800); + gdImageColorAllocate(im, 0xFF, 0xFF, 0xFF); /* allocate white for background color */ + black = gdImageColorAllocate(im, 0, 0, 0); + cos_t = cos(DELTA); + sin_t = sin(DELTA); + x = 100; + y = 0; + for (i = 0; i < 16; i++) { + if (gdImageStringFT(im, brect, black, path, 24, DELTA*i, 400+x, 400+y, "ABCDEF")) { + error = 1; + goto done; + } + for (j = 0; j < 8; j++) { + if (brect[j] != EXPECT[i][j]) { + printf("(%d, %d) (%d, %d) (%d, %d) (%d, %d) expected, but (%d, %d) (%d, %d) (%d, %d) (%d, %d)\n", + EXPECT[i][0], EXPECT[i][1], EXPECT[i][2], EXPECT[i][3], + EXPECT[i][4], EXPECT[i][5], EXPECT[i][6], EXPECT[i][7], + brect[0], brect[1], brect[2], brect[3], + brect[4], brect[5], brect[6], brect[7]); + error = 1; + goto done; + } + } + gdImagePolygon(im, (gdPointPtr)brect, 4, black); + gdImageFilledEllipse(im, brect[0], brect[1], 8, 8, black); + temp = (int)(cos_t * x + sin_t * y); + y = (int)(cos_t * y - sin_t * x); + x = temp; + } + fp = fopen("gdimagestringft_bbox.png", "wb"); + if (!fp) { + error = 1; + goto done; + } + gdImagePng(im, fp); + fclose(fp); +done: + gdImageDestroy(im); + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagestringftex/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagestringftex/CMakeLists.txt new file mode 100644 index 00000000000..5d2666883d8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagestringftex/CMakeLists.txt @@ -0,0 +1,9 @@ +SET(TESTS_FILES + gdimagestringftex_returnfontpathname +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdimagestringftex/gdimagestringftex_returnfontpathname.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagestringftex/gdimagestringftex_returnfontpathname.c new file mode 100644 index 00000000000..f91485b7717 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdimagestringftex/gdimagestringftex_returnfontpathname.c @@ -0,0 +1,22 @@ +#include <string.h> +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdFTStringExtra strex; + char path[2048]; + + sprintf(path, "%s/freetype/DejaVuSans.ttf", GDTEST_TOP_DIR); + strex.flags = gdFTEX_RETURNFONTPATHNAME; + strex.fontpath = NULL; + gdImageStringFTEx(NULL, NULL, 0, path, 72, 0, 0, 0, "hello, gd", &strex); + if (!strex.fontpath) { + return 1; + } + if (strcmp(path, strex.fontpath) != 0) { + return 2; + } + gdFree(strex.fontpath); + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdinterpolatedscale/gdModesAndPalettes.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdinterpolatedscale/gdModesAndPalettes.c new file mode 100644 index 00000000000..a6ed14d92f3 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdinterpolatedscale/gdModesAndPalettes.c @@ -0,0 +1,48 @@ +/* Exercise all scaling with all interpolation modes and ensure that + * at least, something comes back. */ + +#include <stdio.h> + +#include "gd.h" +#include "gdtest.h" + +#define X 100 +#define Y 100 + +#define NX 20 +#define NY 20 + +int main() { + int method, i; + + for(method = GD_BELL; method <= GD_TRIANGLE; method++) { /* GD_WEIGHTED4 is unsupported. */ + gdImagePtr im[2]; + + // printf("Method = %d\n", method); + im[0] = gdImageCreateTrueColor(X, Y); + im[1] = gdImageCreatePalette(X, Y); + + for (i = 0; i < 2; i++) { + gdImagePtr result; + + // printf(" %s\n", i == 0 ? "truecolor" : "palette"); + + gdImageFilledRectangle(im[i], 0, 0, X-1, Y-1, + gdImageColorExactAlpha(im[i], 255, 255, 255, 0)); + + gdImageSetInterpolationMethod(im[i], method); + gdTestAssert(im[i]->interpolation_id == method); /* No getter yet. */ + + result = gdImageScale(im[i], NX, NY); + gdTestAssert(result != NULL); + gdTestAssert(result != im[i]); + gdTestAssert(result->sx == NX && result->sy == NY); + + gdImageDestroy(result); + gdImageDestroy(im[i]); + }/* for */ + }/* for*/ + + + return gdNumFailures(); +}/* main*/ diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdinterpolatedscale/gdTrivialResize.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdinterpolatedscale/gdTrivialResize.c new file mode 100644 index 00000000000..f11b5059fbf --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdinterpolatedscale/gdTrivialResize.c @@ -0,0 +1,94 @@ +#include <stdio.h> + +#include "gd.h" +#include "gdtest.h" + +/* Test gdImageScale() with bicubic interpolation on a simple + * all-white image. */ + +gdImagePtr mkwhite(int x, int y) +{ + gdImagePtr im; + + im = gdImageCreateTrueColor(x, y); + gdImageFilledRectangle(im, 0, 0, x-1, y-1, + gdImageColorExactAlpha(im, 255, 255, 255, 0)); + + gdTestAssert(im != NULL); + + gdImageSetInterpolationMethod(im, GD_BICUBIC); // FP interp'n + + return im; +}/* mkwhite*/ + + +/* Fill with almost-black. */ +void mkblack(gdImagePtr ptr) +{ + gdImageFilledRectangle(ptr, 0, 0, ptr->sx - 1, ptr->sy - 1, + gdImageColorExactAlpha(ptr, 2, 2, 2, 0)); +}/* mkblack*/ + + +#define CLOSE_ENOUGH 15 + +void scaletest(int x, int y, int nx, int ny) +{ + gdImagePtr im, imref, tmp, same; + + imref = mkwhite(x, y); + im = mkwhite(x, y); + tmp = gdImageScale(im, nx, ny); + same = gdImageScale(tmp, x, y); + + /* Test the result to insure that it's close enough to the + * original. */ + gdTestAssert(gdMaxPixelDiff(im, same) < CLOSE_ENOUGH); + + /* Modify the original and test for a change again. (I.e. test + * for accidentally shared memory.) */ + mkblack(tmp); + gdTestAssert(gdMaxPixelDiff(imref, same) < CLOSE_ENOUGH); + + gdImageDestroy(im); + gdImageDestroy(tmp); + gdImageDestroy(same); +}/* scaletest*/ + +void do_test(int x, int y, int nx, int ny) +{ + gdImagePtr im, imref, tmp; + gdImagePtr same, same2; + + im = mkwhite(x, y); + imref = mkwhite(x, y); + + same = gdImageScale(im, x, y); + + /* Trivial resize should be a straight copy. */ + gdTestAssert(im != same); + gdTestAssert(gdMaxPixelDiff(im, same) == 0); + gdTestAssert(gdMaxPixelDiff(imref, same) == 0); + + /* Ensure that modifying im doesn't modify same (i.e. see if we + * can catch them accidentally sharing the same pixel buffer.) */ + mkblack(im); + gdTestAssert(gdMaxPixelDiff(imref, same) == 0); + + gdImageDestroy(same); + gdImageDestroy(im); + + /* Scale horizontally, vertically and both. */ + scaletest(x, y, nx, y); + scaletest(x, y, x, ny); + scaletest(x, y, nx, ny); +} + +int main(int argc, char **argv) +{ + + do_test(300, 300, 600, 600); + do_test(3200, 2133, 640, 427); + + return gdNumFailures(); +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdnewfilectx/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdnewfilectx/CMakeLists.txt new file mode 100644 index 00000000000..9fd4caf3797 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdnewfilectx/CMakeLists.txt @@ -0,0 +1,9 @@ +SET(TESTS_FILES + gdnewfilectx_null +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdnewfilectx/gdnewfilectx_null.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdnewfilectx/gdnewfilectx_null.c new file mode 100644 index 00000000000..0da8295ab5c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdnewfilectx/gdnewfilectx_null.c @@ -0,0 +1,7 @@ +#include "gd.h" + +int main() +{ + if (gdNewFileCtx(NULL) != NULL) return 1; + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdtest/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdtest/CMakeLists.txt new file mode 100644 index 00000000000..5f89bc91b75 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdtest/CMakeLists.txt @@ -0,0 +1,4 @@ +SET(GDTEST_TOP_DIR "${GD_SOURCE_DIR}/tests") +CONFIGURE_FILE(test_config.h.cmake test_config.h ESCAPE_QUOTES) +add_library (gdTest STATIC gdtest.c) +target_link_libraries(gdTest ${GD_LIB}) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdtest/gdtest.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdtest/gdtest.c new file mode 100644 index 00000000000..83aba01d77f --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdtest/gdtest.c @@ -0,0 +1,297 @@ +#include <assert.h> +#include <setjmp.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <math.h> +#include <limits.h> +#include "gd.h" + +#include "gdtest.h" +#include "test_config.h" + +/* max is already defined in windows/msvc */ +#ifndef max + static inline int max(int a, int b) {return a > b ? a : b;} +#endif + +void gdSilence(int priority, const char *format, va_list args) +{ + (void)priority; + (void)format; + (void)args; +} + +gdImagePtr gdTestImageFromPng(const char *filename) +{ + gdImagePtr image; + + FILE *fp; + + fp = fopen(filename, "rb"); + + if (!fp) { + return NULL; + } + image = gdImageCreateFromPng(fp); + fclose(fp); + return image; +} + +/* Compare two buffers, returning the number of pixels that are + * different and the maximum difference of any single color channel in + * result_ret. + * + * This function should be rewritten to compare all formats supported by + * cairo_format_t instead of taking a mask as a parameter. + */ +void gdTestImageDiff(gdImagePtr buf_a, gdImagePtr buf_b, + gdImagePtr buf_diff, CuTestImageResult *result_ret) +{ + int x, y; + int c1, c2; +# define UP_DIFF(var) result_ret->max_diff = max((var), result_ret->max_diff) + + for (y = 0; y < gdImageSY(buf_a); y++) { + for (x = 0; x < gdImageSX(buf_a); x++) { + c1 = gdImageGetTrueColorPixel(buf_a, x, y); + c2 = gdImageGetTrueColorPixel(buf_b, x, y); + + /* check if the pixels are the same */ + if (c1 != c2) { + int r1,b1,g1,a1,r2,b2,g2,a2; + unsigned int diff_a,diff_r,diff_g,diff_b; + + a1 = gdTrueColorGetAlpha(c1); + a2 = gdTrueColorGetAlpha(c2); + diff_a = abs (a1 - a2); + diff_a *= 4; /* emphasize */ + + if (diff_a) { + diff_a += 128; /* make sure it's visible */ + } + if (diff_a > gdAlphaMax) { + diff_a = gdAlphaMax/2; + } + + r1 = gdTrueColorGetRed(c1); + r2 = gdTrueColorGetRed(c2); + diff_r = abs (r1 - r2); + /* diff_r *= 4; /* emphasize */ + if (diff_r) { + diff_r += gdRedMax/2; /* make sure it's visible */ + } + if (diff_r > 255) { + diff_r = 255; + } + + g1 = gdTrueColorGetGreen(c1); + g2 = gdTrueColorGetGreen(c2); + diff_g = abs (g1 - g2); + + diff_g *= 4; /* emphasize */ + if (diff_g) { + diff_g += gdGreenMax/2; /* make sure it's visible */ + } + if (diff_g > 255) { + diff_g = 255; + } + + b1 = gdTrueColorGetBlue(c1); + b2 = gdTrueColorGetBlue(c2); + diff_b = abs (b1 - b2); + diff_b *= 4; /* emphasize */ + if (diff_b) { + diff_b += gdBlueMax/2; /* make sure it's visible */ + } + if (diff_b > 255) { + diff_b = 255; + } + + result_ret->pixels_changed++; + if (buf_diff) gdImageSetPixel(buf_diff, x,y, gdTrueColorAlpha(diff_r, diff_g, diff_b, diff_a)); + } else { + if (buf_diff) gdImageSetPixel(buf_diff, x,y, gdTrueColorAlpha(255,255,255,0)); + } + } + } +# undef UP_DIFF +} + + +/* Return the largest difference between two corresponding pixels and + * channels. */ +unsigned int gdMaxPixelDiff(gdImagePtr a, gdImagePtr b) +{ + int diff = 0; + int x, y; + + if (a == NULL || b == NULL || a->sx != b->sx || a->sy != b->sy) + return UINT_MAX; + + for (x = 0; x < a->sx; x++) { + for (y = 0; y < a->sy; y++) { + int c1, c2; + + c1 = gdImageGetTrueColorPixel(a, x, y); + c2 = gdImageGetTrueColorPixel(b, x, y); + if (c1 == c2) continue; + + diff = max(diff, abs(gdTrueColorGetAlpha(c1) - gdTrueColorGetAlpha(c2))); + diff = max(diff, abs(gdTrueColorGetRed(c1) - gdTrueColorGetRed(c2))); + diff = max(diff, abs(gdTrueColorGetGreen(c1) - gdTrueColorGetGreen(c2))); + diff = max(diff, abs(gdTrueColorGetBlue(c1) - gdTrueColorGetBlue(c2))); + }/* for */ + }/* for */ + + return diff; +} + + +int gdTestImageCompareToImage(const char* file, unsigned int line, const char* message, + gdImagePtr expected, gdImagePtr actual) +{ + unsigned int width_a, height_a; + unsigned int width_b, height_b; + gdImagePtr surface_diff = NULL; + CuTestImageResult result = {0, 0}; + + (void)message; + + if (!actual) { + _gdTestErrorMsg(file, line, "Image is NULL\n"); + goto fail; + } + + width_a = gdImageSX(expected); + height_a = gdImageSY(expected); + width_b = gdImageSX(actual); + height_b = gdImageSY(actual); + + if (width_a != width_b || height_a != height_b) { + _gdTestErrorMsg(file, line, + "Image size mismatch: (%ux%u) vs. (%ux%u)\n for %s vs. buffer\n", + width_a, height_a, + width_b, height_b, + file); + goto fail; + } + + surface_diff = gdImageCreateTrueColor(width_a, height_a); + + gdTestImageDiff(expected, actual, surface_diff, &result); + if (result.pixels_changed>0) { + char file_diff[255]; + char file_out[1024]; + FILE *fp; + int len, p; + + _gdTestErrorMsg(file, line, + "Total pixels changed: %d with a maximum channel difference of %d.\n", + result.pixels_changed, + result.max_diff + ); + + p = len = strlen(file); + p--; + + /* Use only the filename (and store it in the bld dir not the src dir + */ + while(p > 0 && (file[p] != '/' && file[p] != '\\')) { + p--; + } + sprintf(file_diff, "%s_%u_diff.png", file + p + 1, line); + sprintf(file_out, "%s_%u_out.png", file + p + 1, line); + + fp = fopen(file_diff, "wb"); + if (!fp) goto fail; + gdImagePng(surface_diff,fp); + fclose(fp); + + fp = fopen(file_out, "wb"); + if (!fp) goto fail; + gdImagePng(actual, fp); + fclose(fp); + } else { + if (surface_diff) { + gdImageDestroy(surface_diff); + } + return 1; + } + +fail: + if (surface_diff) { + gdImageDestroy(surface_diff); + } + return 0; +} + +int gdTestImageCompareToFile(const char* file, unsigned int line, const char* message, + const char *expected_file, gdImagePtr actual) +{ + gdImagePtr expected; + int res = 1; + + expected = gdTestImageFromPng(expected_file); + + if (!expected) { + _gdTestErrorMsg(file, line, "Cannot open PNG <%s>", expected_file); + res = 0; + } else { + res = gdTestImageCompareToImage(file, line, message, expected, actual); + gdImageDestroy(expected); + } + return res; +} + + +static int failureCount = 0; + +int gdNumFailures() { + return failureCount; +} + +int _gdTestAssert(const char* file, unsigned int line, const char* message, int condition) +{ + if (condition) return 1; + _gdTestErrorMsg(file, line, "%s", message); + + ++failureCount; + + return 0; +} + +int _gdTestAssertMsg(const char* file, unsigned int line, int condition, const char* message, ...) +{ + va_list args; + char output_buf[GDTEST_STRING_MAX]; + + if (condition) return 1; + + va_start(args, message); + vsnprintf(output_buf, sizeof(output_buf), message, args); + va_end(args); + fprintf(stderr, "%s:%u: %s", file, line, output_buf); + fflush(stderr); + + ++failureCount; + + return 0; +} + +int _gdTestErrorMsg(const char* file, unsigned int line, const char* format, ...) /* {{{ */ +{ + va_list args; + char output_buf[GDTEST_STRING_MAX]; + + va_start(args, format); + vsnprintf(output_buf, sizeof(output_buf), format, args); + va_end(args); + fprintf(stderr, "%s:%u: %s", file, line, output_buf); + fflush(stderr); + + ++failureCount; + + return 0; +} +/* }}} */ diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdtest/gdtest.h b/Build/source/libs/gd/libgd-2.1.1/tests/gdtest/gdtest.h new file mode 100644 index 00000000000..8f332b39bbb --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdtest/gdtest.h @@ -0,0 +1,54 @@ +#ifndef GD_TEST_H +#define GD_TEST_H + +#include <stdarg.h> +#include "test_config.h" + +#define GDTEST_STRING_MAX 1024 +typedef struct CuTestImageResult CuTestImageResult; +struct CuTestImageResult { + unsigned int pixels_changed; + unsigned int max_diff; +}; + + +/* Internal versions of assert functions -- use the public versions */ +gdImagePtr gdTestImageFromPng(const char *filename); + +void gdTestImageDiff(gdImagePtr buf_a, gdImagePtr buf_b, + gdImagePtr buf_diff, CuTestImageResult *result_ret); + +int gdTestImageCompareToImage(const char* file, unsigned int line, const char* message, + gdImagePtr expected, gdImagePtr actual); + +int gdTestImageCompareToFile(const char* file, unsigned int line, const char* message, + const char *expected_file, gdImagePtr actual); + +unsigned int gdMaxPixelDiff(gdImagePtr a, gdImagePtr b); + +int _gdTestAssert(const char* file, unsigned int line, const char* message, int condition); + +int _gdTestAssertMsg(const char* file, unsigned int line, int condition, const char* message, ...); + + +int _gdTestErrorMsg(const char* file, unsigned int line, const char* string, ...); + +/* public assert functions */ +#define gdAssertImageEqualsToFile(ex,ac) gdTestImageCompareToFile(__FILE__,__LINE__,NULL,(ex),(ac)) +#define gdAssertImageFileEqualsMsg(ex,ac) gdTestImageCompareFiles(__FILE__,__LINE__,(ms),(ex),(ac)) + +#define gdAssertImageEquals(tc,ex,ac) CuAssertImageEquals_LineMsg((tc),__FILE__,__LINE__,NULL,(ex),(ac)) +#define gdAssertImageEqualsMsg(tc,ex,ac) CuAssertImageEquals_LineMsg((tc),__FILE__,__LINE__,(ms),(ex),(ac)) + +#define gdTestAssert(cond) _gdTestAssert(__FILE__, __LINE__, "assert failed in <%s:%i>\n", (cond)) + +#define gdTestAssertMsg(cond, message, ...) _gdTestAssertMsg(__FILE__, __LINE__, (cond),(message),__VA_ARGS__) + + +#define gdTestErrorMsg(...) _gdTestErrorMsg(__FILE__, __LINE__, __VA_ARGS__) + +void gdSilence(int priority, const char *format, va_list args); + +int gdNumFailures(void); + +#endif /* GD_TEST_H */ diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdtest/test_config.h.cmake b/Build/source/libs/gd/libgd-2.1.1/tests/gdtest/test_config.h.cmake new file mode 100644 index 00000000000..59d2f0cf7ed --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdtest/test_config.h.cmake @@ -0,0 +1,4 @@ +/* Define the full path to the top src dir, required to get the path + * of each input data */ +#cmakedefine GDTEST_TOP_DIR "@GDTEST_TOP_DIR@" + diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdtiled/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gdtiled/CMakeLists.txt new file mode 100644 index 00000000000..cc47150c832 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdtiled/CMakeLists.txt @@ -0,0 +1,9 @@ +SET(TESTS_FILES + bug00032 +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdtiled/bug00032.c b/Build/source/libs/gd/libgd-2.1.1/tests/gdtiled/bug00032.c new file mode 100644 index 00000000000..0e711533f10 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdtiled/bug00032.c @@ -0,0 +1,41 @@ +#include "gd.h" +#include <stdio.h> +#include "gdtest.h" + +#define exp_img "bug00032_exp.png" + +#ifdef _MSC_VER +# define snprintf _snprintf +#endif + +int main() +{ + gdImagePtr im, tile; + char path[GDTEST_STRING_MAX]; + + gdSetErrorMethod(gdSilence); + + snprintf(path, GDTEST_STRING_MAX - 1, "%s/gdtiled/%s", GDTEST_TOP_DIR, exp_img); + + tile = gdImageCreateTrueColor(10, 10); + gdImageFill(tile, 0, 0, 0xFFFFFF); + gdImageLine(tile, 0,0, 9,9, 0xff0000); + gdImageColorTransparent(tile, 0xFFFFFF); + + im = gdImageCreateTrueColor(50, 50); + gdImageFilledRectangle(im, 0, 0, 25, 25, 0x00FF00); + + gdImageSetTile(im, tile); + gdImageFilledRectangle(im, 10, 10, 49, 49, gdTiled); + + if (!gdAssertImageEqualsToFile(path, im)) { + gdImageDestroy(im); + gdImageDestroy(tile); + return 1; + } + + gdImageDestroy(im); + gdImageDestroy(tile); + return 0; +} + diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gdtiled/bug00032_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gdtiled/bug00032_exp.png Binary files differnew file mode 100644 index 00000000000..2bee38eebad --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gdtiled/bug00032_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/gif/CMakeLists.txt new file mode 100644 index 00000000000..a64f785d8e8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/CMakeLists.txt @@ -0,0 +1,18 @@ + +SET(TESTS_FILES + gif_im2im + gif_null + bug00005 + bug00005_2 + bug00006 + bug00060 + bug00066 + bug00181 + bug00227 +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005.c b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005.c new file mode 100644 index 00000000000..1911e6a17a9 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005.c @@ -0,0 +1,46 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + char * giffiles[4] = {"bug00005_0.gif", "bug00005_1.gif", "bug00005_2.gif", "bug00005_3.gif"}; + int valid[4] = {0, 0, 0, 0}; + char *exp[4] = {NULL, NULL, "bug00005_2_exp.png", NULL}; + const int files_cnt = 4; + FILE *fp; + int i = 0; + int error = 0; + char path[1024]; + + for (i=0; i < files_cnt; i++) { + sprintf(path, "%s/gif/%s", GDTEST_TOP_DIR, giffiles[i]); + + fp = fopen(path, "rb"); + if (!fp) { + gdTestErrorMsg("<%s> Input file does not exist!\n", path); + return 1; + } + + im = gdImageCreateFromGif(fp); + fclose(fp); + + if (valid[i]) { + if (!im) { + error = 1; + } else { + sprintf(path, "%s/gif/%s", GDTEST_TOP_DIR, exp[i]); + if (!gdAssertImageEqualsToFile(path, im)) { + error = 1; + } + gdImageDestroy(im); + } + } else { + if (!gdTestAssert(im == NULL)) { + error = 1; + } + } + } + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_0.gif b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_0.gif Binary files differnew file mode 100644 index 00000000000..753156014d4 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_0.gif diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_1.gif b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_1.gif new file mode 100644 index 00000000000..76ce1e398ec --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_1.gif @@ -0,0 +1,4 @@ +GIF89a
+<
+
+¿´°É, ÎÒ¶¼Ëµ¹ýÂ˲»ÑÏÁË
\ No newline at end of file diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_2.c b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_2.c new file mode 100644 index 00000000000..de7d3d17f97 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_2.c @@ -0,0 +1,455 @@ +#include <stdio.h> +#include <stdlib.h> +#include "gd.h" + +static const unsigned char gifdata[8994] = {71,73,70,56,55,97,20,1,110, + 0,247,0,0,247,247,247,255,251,255,231,231,231,214,211,214,239,235,239, + 206,203,206,173,20,0,222,219,222,24,69,173,24,73,181,16,52,132,16,60, + 148,198,24,0,181,178,181,247,243,247,140,16,0,198,190,189,189,186,189, + 24,77,198,231,227,231,239,239,239,198,195,198,247,243,239,189,190,189, + 198,199,198,8,81,8,206,207,206,8,36,99,33,89,214,214,36,8,214,215,214, + 24,81,206,156,158,156,239,186,0,222,223,222,0,101,0,214,174,0,99,150, + 239,49,101,214,74,125,231,8,60,165,181,182,181,156,154,156,115,162,239, + 222,223,231,57,113,222,107,12,0,0,125,8,255,207,0,189,182,189,173,166, + 173,165,162,165,231,73,49,41,81,181,255,117,99,189,150,0,90,138,239,165, + 166,165,16,69,181,173,170,173,198,158,0,173,174,173,247,105,82,231,60, + 33,253,253,253,239,89,66,99,211,99,222,48,24,90,203,90,181,36,16,132, + 170,247,249,249,249,148,121,0,16,150,24,181,142,0,132,105,0,99,81,0,41, + 73,148,173,134,0,189,44,24,107,44,33,49,182,57,165,130,0,173,199,247, + 206,60,41,165,190,239,173,170,165,198,215,255,189,227,189,99,121,164, + 107,211,115,247,134,115,255,239,8,90,105,124,140,32,16,148,65,49,132, + 134,148,247,150,132,148,146,140,115,121,140,198,146,140,165,166,173,189, + 207,239,206,213,214,41,65,107,132,125,115,217,215,203,234,234,234,123, + 77,66,239,242,247,148,174,222,203,206,214,74,97,148,132,154,214,222,219, + 214,247,251,255,123,134,173,165,134,123,23,64,154,140,146,148,57,186,66, + 181,178,173,165,170,173,24,162,33,107,105,107,66,195,74,218,229,255,82, + 109,173,198,199,206,156,101,90,123,101,82,73,85,115,59,89,147,123,219, + 132,132,146,181,247,223,90,231,235,239,206,174,165,89,129,214,214,182, + 181,165,182,214,210,210,210,247,186,173,222,227,231,57,97,181,247,166, + 156,148,158,181,231,231,239,194,194,195,181,182,189,217,217,217,181,69, + 49,255,247,255,247,247,255,198,117,107,214,219,231,214,219,221,225,225, + 225,173,150,140,206,199,198,132,117,57,33,170,41,181,186,198,244,244, + 244,156,134,66,181,195,222,255,235,231,231,228,222,206,235,206,231,219, + 222,173,178,181,247,215,41,181,162,99,168,167,167,90,117,90,181,166,140, + 255,203,198,115,142,206,192,191,191,239,231,231,170,146,49,247,215,206, + 189,158,16,255,247,132,241,241,241,255,255,247,206,211,231,185,184,185, + 181,89,74,25,57,127,222,203,140,239,199,41,13,55,146,206,195,165,214, + 101,90,255,239,49,222,203,198,165,174,189,231,235,255,206,174,41,222, + 186,66,12,50,133,201,201,201,255,243,181,178,177,178,181,170,165,239, + 247,239,255,243,239,255,255,239,156,211,165,255,247,247,180,179,178,247, + 231,214,140,203,140,239,227,148,222,239,222,165,164,163,173,142,16,239, + 235,231,255,251,222,214,215,222,247,247,239,10,45,119,90,170,99,25,77, + 189,140,174,140,222,215,214,162,160,160,123,150,123,146,148,154,66,142, + 66,22,74,190,41,93,49,24,121,33,154,153,153,197,196,193,157,154,153,166, + 163,160,215,212,209,3,26,76,11,34,87,148,147,149,42,62,109,152,155,165, + 43,98,218,155,153,151,155,182,242,145,172,230,154,155,159,209,221,243, + 247,235,247,133,133,139,184,181,176,24,46,97,243,244,246,255,255,255,44, + 0,0,0,0,20,1,110,0,0,8,255,0,255,9,28,72,176,160,193,131,8,19,42,92,200, + 176,161,195,135,16,35,74,156,72,177,162,197,139,24,51,106,220,200,177, + 163,199,143,32,67,138,28,73,178,164,201,147,40,83,170,92,201,178,165, + 203,151,48,99,202,156,73,179,166,205,155,56,115,234,220,201,179,167,207, + 159,64,131,10,29,74,180,168,81,154,136,190,41,253,70,132,136,22,45,133, + 162,22,194,114,180,170,213,151,156,204,141,120,241,34,73,168,62,66,158, + 106,9,75,245,170,217,133,153,140,93,49,51,165,138,219,42,83,204,92,49, + 54,231,236,193,0,0,48,233,213,218,245,43,212,168,66,250,68,193,19,205, + 153,221,179,20,116,85,41,113,194,4,7,9,9,18,232,152,28,57,129,4,14,38, + 20,25,49,147,233,48,94,11,4,38,16,168,144,97,107,146,40,78,11,85,139, + 198,186,90,181,178,135,137,226,221,196,72,145,227,15,184,63,64,78,128, + 162,183,111,223,146,117,124,48,81,98,138,49,179,1,28,8,56,160,161,64,1, + 116,165,95,236,193,211,52,154,62,76,177,171,78,114,211,130,195,7,14,224, + 193,75,255,144,160,163,55,130,38,132,224,252,249,3,135,80,147,5,11,80, + 32,184,204,225,196,138,43,86,147,11,240,128,33,70,10,232,35,140,224,21, + 30,120,84,147,138,0,22,0,144,221,80,186,196,226,29,110,225,237,38,31,33, + 89,72,82,9,6,26,168,225,129,28,28,14,0,136,36,89,16,2,95,13,152,181,80, + 2,126,71,129,118,64,5,13,244,0,93,116,123,12,166,197,1,44,16,160,224, + 130,63,109,162,200,120,16,122,183,219,121,89,148,1,65,5,16,64,112,193, + 145,69,14,137,161,28,34,28,32,74,22,35,154,208,130,125,126,24,21,0,5,34, + 176,40,131,43,25,192,136,71,31,90,164,82,227,141,56,234,132,151,33,8, + 160,96,89,110,227,241,134,64,144,41,52,32,103,4,116,214,105,231,5,69,98, + 48,128,8,128,100,161,192,2,53,76,137,67,21,157,17,165,220,0,41,108,217, + 229,86,95,17,81,8,1,20,56,64,102,153,56,29,208,132,2,10,200,103,217,143, + 40,16,162,130,156,13,164,144,39,6,164,146,58,100,157,49,248,119,164,6, + 114,84,66,136,2,8,152,255,112,2,14,43,84,57,84,0,251,37,202,101,116,95, + 9,81,136,3,120,81,154,19,94,19,192,177,193,6,127,34,96,153,155,89,88,33, + 231,5,21,96,56,192,1,7,136,96,237,1,26,14,208,28,4,254,197,217,64,12,24, + 142,177,193,2,144,204,90,130,25,183,98,201,98,26,139,190,208,107,33,216, + 9,155,19,104,44,12,48,200,177,201,78,86,195,29,161,66,160,193,180,19,32, + 8,105,130,160,81,0,218,181,26,96,112,65,139,45,70,160,1,24,200,6,90,66, + 113,66,1,96,193,1,16,52,192,46,175,96,193,43,47,78,42,42,156,199,189, + 200,198,87,131,10,162,22,224,129,104,145,254,19,64,0,46,199,236,50,0,22, + 19,32,128,28,3,84,16,129,156,50,52,128,193,29,17,155,88,66,21,62,189, + 236,50,150,25,111,204,104,199,147,126,252,146,209,120,9,48,192,5,59,204, + 0,2,201,10,52,33,195,5,42,215,40,233,66,80,31,189,92,1,25,91,145,195, + 214,226,42,80,195,9,19,79,1,84,114,44,96,208,0,24,237,190,27,175,211,52, + 29,74,181,10,124,223,255,155,117,4,123,18,240,181,68,120,133,54,64,198, + 85,231,16,65,23,17,179,77,113,209,14,28,32,247,29,117,119,236,0,222,53, + 133,220,192,12,124,131,192,184,2,89,8,222,52,225,14,16,112,64,1,41,88, + 61,67,15,104,140,107,2,14,19,219,218,19,0,19,20,208,0,229,48,130,165, + 133,5,152,215,164,220,138,155,131,48,67,30,116,16,82,67,41,26,93,57,118, + 10,57,204,144,3,208,27,196,10,251,10,133,238,132,215,233,41,136,209,238, + 30,186,243,222,251,76,250,1,111,197,14,128,159,178,201,38,28,209,139,65, + 234,32,200,224,247,218,19,27,209,19,177,168,107,159,123,88,163,127,239, + 82,114,166,235,44,234,0,4,216,8,212,126,87,129,30,88,77,12,199,90,192, + 235,86,80,2,217,233,132,118,168,83,193,246,116,103,24,253,129,175,116, + 204,193,64,1,0,152,63,140,232,205,10,237,123,159,137,86,32,63,235,65,48, + 5,18,188,159,22,42,104,193,153,28,140,90,19,160,64,7,47,2,183,245,89,13, + 98,174,163,213,125,120,162,28,13,196,32,133,91,153,78,88,255,88,216,66, + 23,18,224,136,51,164,33,6,11,168,2,16,180,78,109,38,50,130,17,234,114, + 16,0,240,65,4,120,225,3,11,60,192,135,46,34,4,106,212,112,68,36,194,176, + 133,45,132,33,18,142,160,134,68,148,19,193,237,225,97,136,63,217,198,50, + 110,113,136,58,214,241,22,203,216,6,52,72,98,10,88,140,177,140,101,12, + 131,35,106,241,12,1,210,76,36,81,211,64,240,62,167,64,28,24,161,86,8, + 153,0,31,48,240,15,8,240,225,0,22,136,1,31,12,134,144,89,132,65,24,52,8, + 101,40,127,240,131,33,144,50,8,97,168,133,67,162,214,70,47,57,229,26,5, + 97,68,44,98,17,135,90,74,81,138,111,129,203,20,118,201,203,43,248,161, + 13,31,209,134,47,126,1,131,98,194,32,4,200,76,102,8,126,113,136,91,236, + 177,35,169,248,100,16,70,73,202,33,116,160,3,67,24,2,13,124,16,9,83,240, + 4,102,87,90,81,213,210,144,192,181,145,144,104,7,145,36,4,2,144,134,28, + 76,224,31,23,224,195,93,0,64,6,107,254,64,148,165,236,64,17,246,201,255, + 128,107,254,192,6,170,100,8,0,4,208,202,32,82,71,11,176,140,217,149,36, + 177,128,76,169,105,60,37,50,215,196,38,134,131,19,88,116,86,70,184,66, + 245,44,114,10,100,32,179,152,200,36,1,9,120,96,139,146,222,224,6,60,32, + 65,8,96,112,136,109,104,36,21,194,200,230,61,105,144,207,34,60,225,166, + 69,48,64,63,181,185,5,53,242,132,118,138,228,220,19,17,16,69,35,28,199, + 32,26,224,3,1,26,112,201,119,90,242,32,169,184,196,78,171,217,129,39, + 240,130,12,137,88,68,34,200,112,137,125,242,212,155,10,233,97,12,64,224, + 198,87,202,44,88,19,160,67,67,227,51,31,204,152,139,129,37,168,168,99, + 30,3,209,19,24,149,34,201,241,133,74,149,41,82,91,176,34,24,159,200,144, + 26,130,193,138,108,40,129,7,43,61,196,51,35,2,78,10,104,162,3,12,48,37, + 85,159,160,137,172,106,128,24,159,72,132,38,114,138,77,26,132,1,172,53, + 129,217,204,164,118,1,25,56,17,89,210,147,34,186,12,162,177,127,8,143,0, + 148,204,129,60,11,66,140,39,255,48,160,159,216,132,236,37,154,113,6,78, + 208,8,17,109,64,68,34,190,80,4,42,252,192,7,176,80,200,64,7,16,1,32,118, + 229,160,9,197,139,114,2,102,129,62,101,225,186,116,128,132,4,164,116, + 209,22,56,230,15,113,96,4,35,36,241,135,182,158,160,10,84,132,200,41, + 142,33,82,190,242,128,21,16,56,131,7,6,48,45,22,76,2,75,175,200,198,13, + 72,0,131,97,44,131,34,226,160,194,109,177,105,77,125,6,226,2,103,72,48, + 181,30,1,220,3,144,193,11,197,61,110,114,135,69,129,21,153,205,111,11, + 224,0,173,140,128,206,130,16,160,80,162,13,86,65,82,241,4,157,226,22, + 178,129,16,5,145,134,228,28,149,33,226,17,129,48,0,21,104,16,4,71,36, + 100,185,99,109,87,18,14,138,138,129,76,87,91,27,164,47,171,36,161,172, + 203,152,192,49,18,128,68,49,6,112,138,89,12,236,13,229,149,18,36,31,162, + 6,91,164,116,175,125,125,133,145,144,84,129,22,79,139,0,106,160,133,19, + 248,203,133,91,72,100,17,69,184,237,137,25,80,4,79,108,121,255,72,16,32, + 213,6,15,208,134,79,124,65,198,52,142,196,3,107,215,0,25,48,210,156,82, + 188,156,68,44,118,9,3,232,244,154,144,229,197,183,184,76,36,57,31,0,198, + 50,14,130,15,108,124,144,67,69,128,172,209,217,177,83,80,209,216,45,22, + 64,97,17,136,65,3,46,64,135,100,141,103,60,58,248,3,215,228,252,175,3, + 32,136,14,177,98,27,138,24,162,6,148,94,89,164,36,176,133,226,34,16,231, + 82,193,217,209,7,32,197,152,97,80,102,176,129,243,31,139,48,244,128,33, + 203,102,79,48,58,206,43,150,115,147,238,76,5,73,235,153,38,33,6,0,1,166, + 182,131,180,41,32,1,81,156,50,67,178,77,207,7,60,224,208,215,164,194, + 168,53,248,175,230,232,12,79,16,208,16,113,183,137,220,42,74,237,210,58, + 230,177,64,146,131,165,109,249,103,110,152,90,0,2,116,16,153,84,167,128, + 215,165,234,242,156,181,81,222,22,192,110,214,9,81,131,126,121,112,235, + 145,190,2,90,210,202,150,187,35,0,111,109,129,66,10,100,54,115,67,62,97, + 104,19,171,153,1,110,255,134,64,1,254,165,241,156,113,188,72,30,40,0,20, + 188,80,109,110,230,164,194,5,244,182,244,86,176,130,213,62,36,57,7,240, + 130,185,15,157,77,50,204,57,96,4,176,214,0,200,230,31,135,205,224,1,79, + 144,180,13,64,235,227,123,99,218,52,250,222,183,182,39,0,100,12,148,97, + 173,69,30,79,13,122,112,1,118,107,43,97,120,170,0,198,0,197,54,113,27, + 132,118,180,80,2,74,113,45,82,248,22,128,70,162,57,162,0,4,192,117,166, + 167,32,5,111,104,198,18,156,16,2,46,20,219,32,80,11,0,137,149,125,114,6, + 104,194,57,129,59,98,192,248,190,116,110,249,231,13,79,47,194,54,109,64, + 233,208,226,124,110,200,130,213,2,87,224,182,159,59,160,13,117,112,129, + 234,207,221,89,181,67,74,82,52,163,151,203,229,4,8,54,60,128,10,62,176, + 65,24,246,173,245,123,59,87,211,66,232,241,64,94,182,117,230,192,33,89, + 155,26,143,36,156,67,35,190,55,233,211,23,56,184,6,224,208,200,18,76, + 241,46,14,96,133,20,228,94,241,99,64,192,3,53,74,208,255,141,10,183,28, + 13,64,192,91,128,0,197,18,110,64,108,46,252,119,158,0,8,196,185,77,126, + 219,75,0,98,101,71,28,156,116,199,118,126,57,97,192,246,81,103,3,0,101, + 19,112,195,34,16,131,41,8,80,31,60,215,97,227,134,65,80,160,122,46,96, + 110,69,208,1,52,48,38,5,17,123,82,131,56,162,144,6,46,240,4,52,32,128, + 201,149,109,86,167,99,168,17,124,136,7,0,20,48,11,197,128,124,18,144,27, + 89,160,50,175,39,41,178,231,63,16,0,6,106,227,56,165,71,16,201,17,12,82, + 224,4,135,69,119,36,144,8,43,51,56,5,129,23,203,133,56,217,195,4,32,71, + 108,195,128,16,52,147,8,67,71,127,12,208,12,156,48,1,68,168,131,52,115, + 111,13,176,3,49,144,122,52,151,123,91,112,55,50,81,128,160,23,112,245, + 81,2,43,192,128,11,97,49,181,35,8,16,24,129,58,53,4,226,160,92,164,213, + 34,98,224,2,95,104,3,91,112,129,190,71,130,68,96,130,111,71,1,197,130, + 124,185,193,1,162,112,10,54,130,133,203,85,64,183,227,58,104,255,184,2, + 192,52,124,14,48,1,180,208,131,115,183,87,200,192,9,8,178,134,22,112, + 111,59,96,54,76,176,126,133,119,120,4,97,49,143,240,5,243,183,108,12, + 192,11,154,40,104,9,1,55,220,102,54,80,0,117,65,32,128,157,55,134,3,229, + 67,7,248,39,28,224,112,214,247,16,203,117,1,61,32,6,130,240,128,112,200, + 0,52,16,9,133,116,23,234,210,0,32,52,139,1,104,3,19,38,16,203,133,111, + 153,86,130,194,119,129,181,131,6,132,136,27,138,96,129,136,23,57,114, + 195,57,17,163,67,83,0,53,218,22,1,72,96,137,41,149,76,193,176,137,227, + 102,1,181,195,60,101,32,8,131,71,102,195,176,88,51,67,0,205,16,133,39, + 214,1,137,208,50,13,40,57,155,147,3,108,224,2,154,167,135,91,64,117,49, + 1,65,23,144,54,2,183,93,22,181,2,192,40,0,65,197,55,42,144,6,108,240, + 128,15,208,79,158,197,144,212,120,111,57,80,6,179,152,144,54,112,109,33, + 57,0,63,228,135,128,88,138,88,162,7,1,55,31,223,241,1,110,144,136,243, + 180,109,84,255,131,64,55,72,66,70,112,35,218,22,108,235,232,4,251,181, + 87,199,16,67,192,136,147,86,80,143,76,128,4,60,208,126,214,144,109,4,0, + 99,254,136,104,84,128,73,171,68,59,83,35,3,6,137,135,213,182,5,156,87, + 19,16,180,56,37,51,31,82,98,34,15,161,55,50,128,145,159,210,0,117,128, + 138,6,224,79,91,48,141,251,134,115,61,144,3,15,88,92,185,103,3,203,248, + 15,213,120,117,93,81,130,176,161,117,245,2,52,166,6,30,38,112,6,135,244, + 69,23,99,59,132,73,84,214,183,2,44,64,141,19,128,1,75,176,142,63,152,76, + 190,96,147,13,113,37,89,178,57,105,176,148,55,48,138,77,56,16,160,81,1, + 66,119,110,184,85,116,9,242,115,4,16,55,73,233,134,180,168,144,153,115, + 111,198,82,152,142,161,8,171,132,65,253,97,54,86,195,133,52,178,8,154, + 224,5,68,55,105,227,71,59,114,67,146,231,86,109,54,224,3,1,197,151,219, + 214,92,44,25,152,46,115,49,26,0,145,9,120,100,138,160,153,78,56,153,101, + 184,115,43,160,11,206,41,2,175,255,80,153,62,216,142,200,164,6,233,229, + 16,185,232,153,161,168,4,100,198,5,62,165,109,44,224,9,17,136,154,216, + 68,74,196,144,68,149,38,53,41,160,7,176,153,144,94,153,10,23,52,143,220, + 152,44,223,1,30,184,153,155,229,215,31,91,216,51,42,87,35,14,86,104,135, + 246,145,2,97,145,49,96,151,231,22,128,62,176,8,3,81,141,191,7,152,23, + 184,109,16,224,109,9,208,139,45,16,7,210,32,80,22,154,54,222,233,54,180, + 115,6,117,64,158,251,245,81,191,48,9,250,249,118,56,185,3,159,121,143, + 78,41,153,103,16,8,245,25,135,167,36,0,233,217,16,193,216,3,255,137,123, + 94,121,139,79,35,143,5,192,58,127,178,0,9,112,160,31,16,11,16,161,31,19, + 32,2,27,71,39,101,231,98,136,0,156,57,213,79,63,176,5,106,208,6,44,112, + 1,200,105,0,209,136,146,125,25,157,5,193,70,15,137,47,177,118,2,140,208, + 16,108,36,150,176,114,134,67,147,11,166,147,126,50,186,87,48,224,11,55, + 138,120,21,6,1,58,26,138,195,70,108,135,192,151,21,255,86,0,7,57,116, + 157,69,3,154,48,7,131,202,123,225,4,1,170,0,155,145,38,128,187,55,134, + 88,242,51,49,41,28,224,241,1,113,64,56,218,38,0,34,16,115,239,150,36, + 255,210,96,92,101,114,87,213,159,66,167,166,31,168,123,90,247,156,31, + 250,135,129,25,0,78,10,122,168,37,43,56,240,6,70,90,59,35,131,128,189, + 56,49,85,16,140,234,135,4,66,9,168,190,64,17,22,32,2,73,131,168,77,73, + 108,171,192,151,247,198,145,172,55,83,137,48,17,1,208,6,24,147,169,112, + 24,141,91,224,61,45,1,53,141,58,6,49,57,165,163,234,6,20,17,123,20,176, + 28,49,71,54,44,182,65,44,16,92,192,169,9,188,208,85,95,32,8,179,234,129, + 185,215,169,206,201,92,185,42,4,187,234,164,121,0,61,162,135,3,56,0,158, + 2,85,59,48,153,44,189,104,81,165,0,65,13,176,4,127,186,82,48,160,6,208, + 26,174,203,234,4,136,101,173,124,201,103,218,90,4,218,20,4,65,64,12,29, + 139,169,143,170,166,181,40,128,149,74,18,1,32,162,175,2,31,50,255,25,30, + 62,135,87,0,240,99,219,82,175,46,166,32,203,165,49,67,7,176,62,32,176, + 218,166,146,5,187,171,205,120,90,209,3,172,232,3,54,253,102,131,127,50, + 165,101,105,6,210,32,57,57,16,138,204,138,88,43,245,11,218,176,178,170, + 240,177,33,11,3,171,208,13,224,138,1,50,80,178,39,235,3,167,0,182,45, + 235,129,2,104,3,230,186,63,71,91,6,235,218,130,222,97,2,147,144,17,159, + 17,26,204,81,0,141,166,65,3,80,133,173,153,51,242,151,161,244,102,180, + 125,120,141,186,170,141,5,228,103,229,52,43,14,171,16,225,84,0,53,59, + 112,7,106,2,2,32,142,89,75,173,26,251,11,174,120,165,14,16,55,97,75,158, + 99,187,10,22,80,168,118,89,159,69,240,3,82,71,1,222,42,142,105,59,174, + 155,231,3,1,244,15,180,193,75,114,113,5,188,219,187,188,187,187,14,132, + 17,64,87,157,81,90,100,51,153,160,2,228,0,178,215,28,142,118,45,5,32,10, + 182,199,122,137,123,171,72,235,166,195,7,84,155,131,64,65,131,3,200,3, + 54,166,3,147,54,255,219,130,222,40,13,20,144,149,76,16,138,82,112,186, + 49,171,131,72,147,3,24,139,4,135,165,177,168,91,190,165,85,178,174,235, + 3,229,122,165,224,52,186,24,128,161,210,155,123,182,43,16,143,240,42, + 109,229,139,60,199,64,21,213,2,10,76,37,201,131,115,151,18,190,120,75, + 147,31,65,124,161,145,170,243,53,45,56,131,182,167,249,150,52,22,4,108, + 186,184,166,1,162,165,200,159,86,195,56,227,210,139,238,74,185,218,166, + 6,199,39,112,201,39,1,21,155,163,130,224,185,197,116,8,27,101,122,113, + 163,2,149,41,5,51,90,76,191,208,137,204,181,186,17,216,186,62,128,191, + 120,197,191,119,8,169,247,107,3,192,162,32,4,112,124,100,105,31,183,196, + 24,222,101,152,82,22,188,222,106,58,134,80,188,145,33,190,31,48,185,2, + 164,117,228,55,121,56,83,1,117,16,133,29,224,186,65,192,161,212,184,109, + 43,201,184,6,91,132,133,186,3,125,19,49,175,19,186,132,58,11,134,96,179, + 4,87,112,127,96,1,64,28,1,59,48,195,149,25,154,53,188,190,195,135,115, + 49,255,202,172,61,12,3,200,144,139,49,160,10,7,57,196,199,85,180,239, + 138,37,128,0,164,74,140,178,54,0,0,202,115,49,151,146,128,14,71,66,60, + 23,11,127,0,9,53,144,202,36,242,29,43,112,84,20,193,70,151,219,197,185, + 209,2,136,236,173,158,172,188,130,120,56,168,104,159,51,213,156,71,11, + 157,112,44,157,188,90,59,99,213,68,34,164,134,23,104,1,21,208,4,190,161, + 44,147,1,195,52,35,162,135,10,154,26,187,168,89,124,56,203,202,195,206, + 250,15,22,138,164,171,71,196,150,124,205,16,176,203,134,150,198,161,20, + 6,115,144,116,204,33,7,140,35,165,245,1,59,56,224,6,64,182,114,9,118,6, + 111,80,10,140,80,10,55,188,153,71,163,199,92,204,35,184,145,194,40,161, + 28,243,57,149,167,116,187,3,11,204,33,220,184,69,40,162,156,19,66,39, + 124,2,16,87,16,185,240,6,53,208,204,205,44,9,54,130,130,30,32,140,98, + 112,190,75,224,158,53,92,164,14,113,40,23,107,153,230,25,2,79,185,31,73, + 243,205,53,39,176,87,106,177,27,60,85,63,255,176,8,115,192,127,120,186, + 0,219,53,37,39,10,1,28,167,65,154,184,151,22,161,109,5,240,30,46,124, + 106,120,123,0,41,65,44,103,224,150,38,70,96,154,0,149,4,107,189,46,179, + 191,243,168,58,49,160,174,177,86,5,120,44,16,140,112,209,240,17,31,190, + 65,7,53,226,50,145,115,1,32,4,210,75,200,82,181,60,178,103,224,9,59,124, + 153,200,116,10,87,114,166,207,168,122,145,102,196,166,58,1,48,58,149,50, + 149,10,3,181,34,59,243,57,121,90,150,113,112,1,162,134,39,119,23,67,93, + 125,165,41,232,39,2,167,44,47,28,7,109,125,17,22,48,9,158,224,143,59, + 213,1,139,32,213,10,253,151,12,93,132,139,201,60,171,83,0,146,32,122, + 108,51,5,126,48,9,147,64,27,138,80,30,97,13,31,127,98,8,106,176,185,71, + 35,78,178,117,190,76,185,82,171,80,203,188,122,0,111,64,10,204,42,119, + 237,21,2,200,144,9,223,42,57,175,185,122,0,107,3,251,60,110,224,250,6, + 228,140,110,29,32,12,117,97,177,59,64,216,215,105,81,110,64,54,165,255, + 178,65,34,176,185,149,141,23,20,192,80,145,253,194,151,49,0,149,93,17, + 40,216,212,169,184,108,84,32,0,165,232,198,126,121,26,161,29,162,30,192, + 34,73,153,2,226,0,147,53,32,43,143,184,2,56,208,2,31,144,0,178,141,41, + 10,0,7,101,240,9,7,96,163,211,201,103,32,240,209,237,201,219,221,32,17, + 124,122,0,121,128,4,140,124,101,200,20,12,51,3,225,119,56,196,155,135, + 208,21,121,0,253,248,222,136,214,173,216,202,92,144,107,172,190,200,8, + 77,50,45,213,34,2,140,93,17,188,250,6,239,49,112,149,113,106,58,16,7, + 171,121,18,223,138,8,242,87,114,106,6,89,100,48,41,191,156,180,9,241,59, + 114,211,3,61,16,1,114,80,106,255,189,97,70,80,2,45,32,1,40,128,224,104, + 0,7,119,144,7,16,192,65,189,135,40,86,51,195,76,48,108,238,183,70,2,192, + 13,172,48,220,151,72,2,199,176,183,255,112,40,236,51,201,52,39,105,205, + 121,150,2,240,163,154,125,91,84,128,8,251,102,58,131,29,122,9,136,131, + 169,75,1,20,112,68,175,255,135,200,217,38,2,144,32,31,58,158,124,58,0,9, + 7,176,222,239,74,79,37,39,133,29,32,7,103,117,180,57,22,204,202,213,63, + 59,147,2,71,130,6,128,18,110,113,32,9,116,48,6,170,126,7,32,96,5,162,82, + 219,161,139,130,7,128,214,17,14,210,161,201,5,214,48,104,19,160,142,219, + 103,107,184,22,12,55,66,190,89,25,225,204,157,103,186,30,1,179,42,133, + 137,64,69,156,201,34,218,125,134,61,87,132,151,35,98,131,70,0,127,224, + 232,143,222,38,9,32,10,218,73,18,52,67,6,151,222,120,12,112,228,177,62, + 130,158,78,135,7,192,92,114,146,2,161,172,167,56,240,45,102,211,60,61, + 224,229,3,128,32,162,181,111,189,202,57,159,169,132,252,53,12,235,27,0, + 173,173,125,189,78,113,41,133,12,54,57,204,79,106,53,124,160,122,117, + 110,3,176,203,154,44,192,11,243,71,127,188,112,240,159,247,236,109,151, + 179,26,49,11,89,32,31,125,220,199,193,97,8,70,137,18,150,206,120,141, + 119,9,44,128,199,109,122,238,148,219,168,49,96,54,220,8,40,178,255,114, + 2,45,96,8,13,112,54,174,174,114,154,104,1,247,94,117,135,243,208,132, + 172,4,133,151,235,185,41,92,61,200,125,4,111,11,159,64,132,71,248,208, + 143,170,121,53,54,110,251,219,6,153,29,238,183,85,4,75,63,126,88,82,0, + 121,128,241,104,168,241,24,97,237,106,82,112,149,17,28,89,0,230,20,241, + 12,176,176,190,179,32,12,226,126,114,69,176,8,221,206,233,32,128,14,1,2, + 218,113,60,110,251,113,1,121,32,181,238,44,37,38,96,8,17,32,42,26,116,0, + 53,206,140,157,201,57,42,192,6,160,217,95,46,181,153,14,160,1,217,224, + 131,39,85,249,55,144,8,246,158,200,34,96,59,15,253,128,94,0,176,62,37, + 80,0,240,9,57,117,233,37,247,10,240,40,16,209,202,245,140,52,232,95,207, + 17,220,0,9,32,47,25,149,145,38,127,80,0,143,64,68,140,133,108,194,224,8, + 55,74,79,182,213,120,166,79,6,35,63,223,42,9,2,1,98,26,141,34,157,95,52, + 186,5,160,7,70,221,86,101,233,6,233,94,45,49,52,183,246,54,53,61,208,68, + 139,255,191,148,77,57,154,95,4,78,115,112,0,180,96,249,150,255,10,155, + 48,247,164,149,150,124,227,249,79,240,79,41,106,108,81,101,250,37,87,7, + 162,113,239,205,222,0,94,31,237,25,145,11,110,64,30,0,145,64,160,14,129, + 2,17,160,128,164,108,2,174,35,255,28,62,132,24,81,226,191,0,255,22,21, + 161,18,6,214,179,136,1,28,16,35,67,133,193,72,146,6,76,158,172,195,137, + 0,0,137,1,4,28,192,64,110,196,204,17,47,246,68,193,131,101,98,75,0,22, + 42,213,64,129,64,168,4,14,45,78,224,56,99,129,194,82,7,59,37,90,152,160, + 161,193,12,21,32,100,128,98,34,133,71,136,67,208,156,62,60,64,75,201,88, + 178,99,95,157,153,64,97,162,5,17,5,166,170,152,145,131,141,11,47,79,126, + 216,48,245,213,33,177,75,39,253,26,168,163,70,128,131,138,14,3,80,56,80, + 33,79,151,13,27,20,44,144,96,2,71,9,51,122,45,59,228,166,136,160,4,9,6, + 133,30,68,241,103,157,28,10,13,47,79,12,0,64,245,63,98,69,12,48,24,18, + 196,198,255,150,45,154,132,253,232,64,114,228,95,148,7,88,168,149,136, + 233,0,132,112,233,104,214,124,145,100,143,150,211,185,220,36,64,64,48,1, + 231,162,39,226,56,0,48,135,229,233,127,0,8,36,158,106,85,84,154,37,72, + 182,174,90,230,212,129,47,91,55,200,58,145,226,36,219,171,2,7,40,52,149, + 152,235,123,133,240,59,98,4,114,225,129,39,98,115,196,41,0,200,112,237, + 175,7,188,168,163,62,236,10,163,136,2,17,20,99,172,49,5,16,168,193,168, + 202,184,155,232,145,56,58,227,172,32,161,236,88,160,196,44,40,57,128,33, + 14,121,178,160,197,127,196,249,226,1,147,116,99,32,183,221,20,124,96,65, + 79,222,56,96,37,136,60,248,198,28,115,210,121,129,166,12,142,156,41,185, + 61,116,210,11,128,88,164,43,72,7,162,76,104,65,151,21,33,2,64,0,15,32, + 152,106,134,30,0,105,6,20,36,148,32,33,132,85,110,217,198,171,0,44,160, + 198,151,99,120,112,207,9,248,164,144,130,20,43,0,241,192,71,212,178,220, + 178,129,28,188,124,35,135,24,139,232,32,182,72,255,106,49,37,53,10,106, + 33,163,47,191,114,124,224,139,28,240,20,96,187,135,214,156,112,177,198, + 44,196,208,4,35,44,229,16,0,93,98,225,64,74,17,71,44,81,129,38,192,88, + 199,62,32,174,236,200,2,2,4,152,96,130,44,235,240,34,71,222,78,130,20, + 82,47,2,185,211,131,74,33,236,46,26,227,140,60,50,217,12,144,219,227, + 154,175,8,200,2,133,129,10,74,64,202,15,220,128,245,82,7,4,24,128,63,25, + 100,104,160,128,1,94,161,69,138,27,120,40,243,151,95,144,121,19,78,37, + 232,68,34,94,82,196,168,164,130,1,6,251,202,35,45,185,252,182,129,55,60, + 240,228,139,25,97,251,129,6,42,68,98,128,87,72,191,168,163,222,123,241, + 131,8,83,10,55,232,167,226,13,122,233,20,135,42,252,152,195,178,0,8,48, + 35,142,22,62,248,160,51,207,16,40,113,129,199,224,104,229,147,20,129, + 120,53,91,135,84,19,64,4,15,6,24,224,128,73,52,168,3,138,94,127,206,49, + 64,47,216,80,193,97,124,47,245,8,19,1,194,33,135,28,87,158,134,218,149, + 52,255,200,9,39,156,106,80,113,106,19,72,164,165,246,51,161,106,136,195, + 141,82,204,240,163,141,43,83,211,178,130,20,122,232,33,5,12,88,152,32, + 24,86,196,26,235,6,187,223,149,34,94,36,64,153,87,15,135,39,176,96,39,8, + 245,237,118,237,182,223,158,32,145,64,4,222,181,215,161,235,240,219,94, + 91,81,99,171,130,29,64,0,163,139,65,228,217,192,27,199,16,152,242,132, + 18,140,152,194,140,43,78,191,194,140,42,220,136,229,4,14,72,54,217,179, + 84,21,160,157,144,59,248,81,166,147,81,96,150,249,210,44,69,24,160,128, + 10,134,23,183,2,79,2,97,3,10,229,151,87,158,141,52,64,136,220,3,192,35, + 246,238,165,3,14,40,224,130,30,64,224,158,123,25,98,208,64,207,157,184, + 1,170,218,83,83,46,17,5,41,57,160,18,135,21,170,184,34,147,203,2,208, + 215,131,236,27,104,160,94,13,88,160,245,147,68,88,153,27,45,72,49,64,82, + 212,65,12,42,208,67,219,240,4,56,80,57,165,126,24,136,0,254,26,0,129,1, + 76,0,17,44,88,4,25,52,193,139,255,47,116,176,131,108,8,68,29,160,215,54, + 201,137,47,98,22,96,1,6,122,48,14,22,178,176,28,119,232,2,33,154,176,0, + 105,113,134,100,55,196,33,103,98,7,29,161,204,142,118,10,32,4,24,100,16, + 1,119,76,96,119,189,235,200,182,14,112,134,236,69,80,130,107,147,1,8, + 196,48,69,49,112,175,12,57,248,158,189,6,3,42,125,97,111,120,92,178,66, + 92,196,8,46,12,244,168,129,15,97,65,249,160,212,67,149,53,193,141,110,4, + 141,64,36,240,1,19,156,192,8,87,56,35,79,190,163,129,10,68,192,143,16, + 168,128,6,6,240,136,71,176,128,27,76,188,64,10,84,161,135,43,238,32,15, + 23,168,15,1,28,32,191,211,172,233,59,221,242,99,4,32,128,1,113,17,242, + 17,156,176,31,4,42,177,200,111,57,18,146,121,194,142,224,28,48,129,2, + 196,64,6,227,192,7,11,119,176,139,64,106,64,20,134,248,131,12,105,136,2, + 94,122,237,51,40,72,217,15,127,136,134,65,140,65,12,173,96,134,50,236, + 115,132,152,33,49,98,74,196,36,254,174,216,61,106,206,255,224,138,89, + 212,192,4,36,217,18,11,188,100,0,124,244,227,5,36,136,191,71,70,242,140, + 31,219,26,2,186,134,178,5,172,42,7,110,27,192,25,0,81,12,67,100,129,16, + 7,73,0,251,90,80,130,41,228,49,34,0,160,192,4,14,160,129,2,64,0,144,21, + 192,64,66,49,80,129,11,56,81,6,59,192,31,4,196,165,77,179,93,9,0,171,28, + 40,4,15,186,73,225,49,52,130,15,77,96,10,32,89,65,19,114,147,0,246,107, + 64,10,118,176,210,29,200,96,23,178,40,128,7,78,113,10,17,216,82,18,245, + 132,131,12,103,104,135,94,8,147,118,104,32,102,23,140,217,138,86,76,67, + 22,141,48,98,51,157,217,17,239,28,192,126,16,196,95,75,165,138,69,252, + 213,139,71,218,204,163,162,190,227,1,13,116,213,171,94,21,215,1,182,248, + 207,110,208,65,1,210,90,35,48,225,160,2,44,198,0,2,255,146,233,44,180, + 113,10,64,208,97,134,53,168,163,251,174,224,177,139,78,0,120,5,40,232, + 240,134,151,201,24,252,241,173,30,224,31,196,96,133,182,9,200,33,120, + 255,5,61,104,31,35,16,131,6,24,246,95,218,12,156,199,182,197,9,75,20,64, + 25,178,216,69,104,35,32,11,89,172,163,2,202,168,0,32,148,161,1,119,104, + 0,181,160,101,36,8,94,88,142,122,196,227,128,112,105,197,44,97,42,14,1, + 80,0,0,74,93,170,68,104,38,208,199,106,212,160,195,227,100,206,4,48,86, + 193,1,84,0,179,90,46,116,103,53,43,192,89,160,129,169,121,67,137,212,41, + 34,96,102,97,7,84,141,193,5,18,138,208,133,106,64,14,90,162,67,137,32, + 113,148,18,84,193,159,212,163,192,5,157,10,86,192,214,247,95,34,208,102, + 73,23,155,26,232,94,15,103,245,5,240,101,171,251,94,158,224,98,13,107, + 152,64,39,14,48,128,70,104,224,19,148,128,64,4,82,192,15,102,228,33,15, + 204,96,219,52,26,48,13,102,236,192,10,173,120,40,51,68,204,140,93,68, + 160,2,141,176,132,54,71,193,76,224,6,151,39,14,144,21,11,68,32,130,235, + 249,70,4,112,163,85,139,8,252,79,213,88,183,39,63,78,13,0,136,69,63,7, + 64,235,49,66,49,255,8,10,86,149,135,240,138,55,161,29,189,64,132,53,9, + 73,17,92,160,9,10,168,129,232,70,7,28,203,92,52,198,19,128,155,140,113, + 60,96,23,35,13,198,212,149,241,140,225,134,95,2,172,36,59,30,235,72,0, + 128,112,81,0,224,130,2,4,56,176,0,58,161,96,6,23,128,18,159,56,109,5,40, + 97,218,10,144,150,120,26,240,192,1,58,177,6,10,172,152,119,101,230,142, + 106,122,162,148,165,244,88,53,29,131,52,83,119,118,229,5,108,23,58,53,0, + 65,12,2,153,179,26,115,181,171,24,128,192,5,26,58,89,225,161,1,203,90, + 94,1,166,231,7,227,158,220,71,210,214,205,116,75,104,61,233,251,248,56, + 53,217,42,12,16,88,12,51,97,31,193,216,71,24,133,172,160,75,43,22,88, + 162,19,44,224,196,1,68,208,9,1,172,129,0,163,0,192,176,31,157,107,110, + 67,122,77,44,40,6,237,58,45,37,29,212,160,12,35,213,230,82,238,76,128, + 52,131,178,0,78,132,40,4,202,176,129,5,64,98,50,163,235,118,190,245,189, + 111,126,247,123,177,124,186,131,99,255,58,61,29,9,72,66,162,34,112,51, + 245,176,67,0,191,14,0,170,223,138,0,99,154,176,207,21,148,96,175,254, + 198,120,198,53,190,113,103,42,10,123,96,16,248,116,62,64,135,79,220,203, + 183,249,2,232,119,178,183,61,25,4,252,213,43,88,129,17,56,62,115,154, + 215,220,230,221,225,86,5,198,32,240,57,154,224,2,98,125,51,95,17,163, + 129,8,244,64,5,42,112,53,2,246,105,132,21,88,233,230,79,135,122,212,93, + 172,180,236,129,252,49,68,81,132,28,8,144,89,238,28,6,123,111,65,3,189, + 37,3,243,42,72,221,236,103,71,187,94,82,195,202,20,184,28,50,28,136,195, + 74,100,205,157,109,121,192,114,72,167,119,150,97,142,173,180,247,221, + 239,102,95,187,91,64,16,118,200,152,192,13,210,216,177,97,34,230,17,86, + 54,96,240,143,201,80,9,98,158,248,191,87,222,242,249,6,64,227,101,48,8, + 199,224,149,239,176,162,25,209,85,32,238,200,76,38,14,151,71,125,234, + 251,157,121,183,228,192,234,8,48,193,233,101,150,165,110,141,225,200, + 145,49,138,236,85,191,255,123,222,79,93,0,173,228,30,231,23,192,129,19, + 84,244,108,124,178,242,237,217,103,120,138,244,222,249,207,95,17,218,60, + 112,129,63,169,160,243,38,96,196,236,5,32,135,44,104,215,90,31,224,64, + 101,136,5,125,242,151,63,86,41,148,42,200,23,144,33,63,0,155,0,134,8, + 138,167,57,163,136,110,152,223,254,247,55,204,182,6,224,202,33,238,28, + 50,39,104,191,232,35,128,88,240,26,243,17,136,82,192,191,4,44,63,143, + 115,11,47,41,0,179,130,140,22,152,2,14,201,133,82,128,132,83,249,37,67, + 176,0,197,82,192,14,84,61,194,209,158,6,136,1,53,208,131,25,34,10,28, + 152,2,14,140,136,110,120,4,55,104,1,9,32,8,175,225,37,20,200,2,17,224, + 50,15,196,193,212,251,54,162,139,168,5,235,62,20,152,163,22,192,1,35, + 168,2,211,73,29,70,96,157,22,120,29,147,97,163,148,161,131,135,201,193, + 40,212,65,196,40,168,63,242,0,109,16,5,56,160,33,130,195,161,46,44,25, + 30,242,33,66,0,1,151,209,47,41,52,67,180,243,58,225,113,43,255,72,154,0, + 1,168,171,25,10,138,130,208,33,29,2,67,149,89,0,56,0,131,6,208,34,202, + 59,195,62,164,57,180,169,41,201,2,36,243,210,146,91,250,131,26,168,1, + 161,224,26,207,112,35,56,24,131,59,176,2,81,147,30,174,243,195,74,4,60, + 231,178,187,40,251,35,192,26,0,174,194,0,81,40,134,155,50,4,58,32,69,48, + 184,131,3,186,162,72,172,128,73,180,196,86,68,59,154,89,48,53,84,53,63, + 106,50,90,76,169,30,8,163,63,137,11,83,18,151,163,113,197,95,140,58,69, + 105,172,224,25,44,9,115,162,6,144,1,61,40,165,135,2,23,77,154,168,74,1, + 198,104,148,58,254,178,158,255,242,168,201,74,129,108,100,178,40,3,44, + 196,202,47,62,148,198,112,244,55,213,152,21,26,115,42,156,65,71,116,244, + 0,233,249,70,112,20,199,119,236,54,8,185,53,165,104,179,233,98,56,2,80, + 55,10,192,53,120,228,199,202,147,180,95,235,199,128,20,200,129,36,200, + 142,107,190,230,27,191,130,84,200,124,57,200,133,116,200,135,132,200, + 129,172,136,194,152,200,8,136,180,200,139,196,200,128,0,59 + }; + +int main(void) +{ + gdImagePtr im; + if ((im = gdImageCreateFromGifPtr(8994, (char*) &gifdata[0])) != NULL) { + gdImageDestroy(im); + return 0; + } else { + return 1; + } +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_2.gif b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_2.gif Binary files differnew file mode 100644 index 00000000000..3f9e6c5e400 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_2.gif diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_2_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_2_exp.png Binary files differnew file mode 100644 index 00000000000..708b8adf00d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_2_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_3.gif b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_3.gif Binary files differnew file mode 100644 index 00000000000..178d27e3574 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00005_3.gif diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00006.c b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00006.c new file mode 100644 index 00000000000..57d7ad01611 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00006.c @@ -0,0 +1,67 @@ +#include <stdio.h> +#include "gd.h" +#include "gdtest.h" + +#define TMP_FN "_tmp_bug0006.gif" + +int main() +{ + gdImagePtr im; + FILE *fp; + const int r = 255, g = 0, b = 0; + int r_f,g_f,b_f, trans_c_f; + int trans_c = gdTrueColorAlpha(r,g,b,0); + int error = 0; + + im = gdImageCreateTrueColor(192, 36); + if (im == NULL) { + gdTestErrorMsg("Cannot create image\n"); + return 1; + } + + gdImageColorTransparent(im, trans_c); + gdImageFilledRectangle(im, 0,0, 192,36, trans_c); + + fp = fopen(TMP_FN, "wb"); + if (!fp) { + gdTestErrorMsg("Cannot open <%s> for writing\n", TMP_FN); + return 1; + } + gdImageGif(im,fp); + fclose(fp); + + gdImageDestroy(im); + + fp = fopen(TMP_FN, "rb"); + if (!fp) { + gdTestErrorMsg("Cannot open <%s> for reading\n", TMP_FN); + return 1; + } + im = gdImageCreateFromGif(fp); + fclose(fp); + + if (!im) { + gdTestErrorMsg("Cannot create image from <%s>\n", TMP_FN); + return 1; + } + + trans_c_f = gdImageGetTransparent(im); + if (gdTestAssert(trans_c_f == 1)) { + r_f = gdImageRed(im, trans_c_f); + g_f = gdImageGreen(im, trans_c_f); + b_f = gdImageBlue(im, trans_c_f); + + if (!gdTestAssert(r_f == r) || !gdTestAssert(g_f==g) || !gdTestAssert(b_f==b)) { + error = 1; + } + } else { + error = 1; + } + + /* Destroy it */ + gdImageDestroy(im); + if (remove(TMP_FN) == -1) { + gdTestErrorMsg("Cannot remove file: <%s>\n", TMP_FN); + } + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00060.c b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00060.c new file mode 100644 index 00000000000..721d3bc401d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00060.c @@ -0,0 +1,24 @@ +#include <stdio.h> +#include "gd.h" +#include "gdtest.h" + + +int main() +{ + gdImagePtr im; + FILE *fp; + char path[1024]; + + sprintf(path, "%s/gif/bug00060.gif", GDTEST_TOP_DIR); + fp = fopen(path, "rb"); + + if (!fp) { + printf("cannot open <%s>\n", path); + return -1; + } + + im = gdImageCreateFromGif(fp); + fclose(fp); + gdImageDestroy(im); + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00060.gif b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00060.gif Binary files differnew file mode 100644 index 00000000000..c8821748057 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00060.gif diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00066.c b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00066.c new file mode 100644 index 00000000000..be24066ca2e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00066.c @@ -0,0 +1,30 @@ +#include <stdio.h> +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + FILE *fp; + char path[1024]; + int error = 0; + + sprintf(path, "%s/gif/bug00066.gif", GDTEST_TOP_DIR); + fp = fopen(path, "rb"); + + if (!fp) { + printf("cannot open <%s>\n", path); + return -1; + } + + im = gdImageCreateFromGif(fp); + fclose(fp); + + sprintf(path, "%s/gif/bug00066_exp.png", GDTEST_TOP_DIR); + if (!gdAssertImageEqualsToFile(path, im)) { + error = 1; + } + gdImageDestroy(im); + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00066.gif b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00066.gif Binary files differnew file mode 100644 index 00000000000..cdf5f29a82e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00066.gif diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00066_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00066_exp.png Binary files differnew file mode 100644 index 00000000000..9f535adc168 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00066_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00181.c b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00181.c new file mode 100644 index 00000000000..27d6481175e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00181.c @@ -0,0 +1,93 @@ +#include <stdio.h> +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im, im2, im3; + FILE *fp; + int black, trans; + int error = 0; + + /* GIFEncode */ + im = gdImageCreate(100, 100); + if (!im) { + gdTestErrorMsg("Cannot create image.\n"); + return 1; + } + im->interlace = 1; + fp = fopen("bug00181.gif", "wb"); + if (!fp) { + gdTestErrorMsg("Cannot open <%s> for writing.\n", "bug00181.gif"); + return 1; + } + gdImageGif(im, fp); + gdImageDestroy(im); + fclose(fp); + + fp = fopen("bug00181.gif", "rb"); + if (!fp) { + gdTestErrorMsg("Cannot open <%s> for reading.\n", "bug00181.gif"); + return 1; + } + im = gdImageCreateFromGif(fp); + fclose(fp); + if (!im) { + gdTestErrorMsg("Cannot create image from <%s>\n", "bug00181.gif"); + return 1; + } + error = !im->interlace; + gdImageDestroy(im); + + if (error) return error; + + /* GIFAnimEncode */ + im = gdImageCreate(100, 100); + im->interlace = 1; + gdImageColorAllocate(im, 255, 255, 255); /* allocate white for background color */ + black = gdImageColorAllocate(im, 0, 0, 0); + trans = gdImageColorAllocate(im, 1, 1, 1); + gdImageRectangle(im, 0, 0, 10, 10, black); + fp = fopen("bug00181a.gif", "wb"); + if (!fp) { + gdTestErrorMsg("Cannot open <%s> for writing.\n", "bug00181a.gif"); + return 1; + } + gdImageGifAnimBegin(im, fp, 1, 3); + gdImageGifAnimAdd(im, fp, 0, 0, 0, 100, 1, NULL); + im2 = gdImageCreate(100, 100); + im2->interlace = 1; + (void)gdImageColorAllocate(im2, 255, 255, 255); + gdImagePaletteCopy (im2, im); + gdImageRectangle(im2, 0, 0, 15, 15, black); + gdImageColorTransparent (im2, trans); + gdImageGifAnimAdd(im2, fp, 0, 0, 0, 100, 1, im); + im3 = gdImageCreate(100, 100); + im3->interlace = 1; + (void)gdImageColorAllocate(im3, 255, 255, 255); + gdImagePaletteCopy (im3, im); + gdImageRectangle(im3, 0, 0, 15, 20, black); + gdImageColorTransparent (im3, trans); + gdImageGifAnimAdd(im3, fp, 0, 0, 0, 100, 1, im2); + gdImageGifAnimEnd(fp); + fclose(fp); + gdImageDestroy(im); + gdImageDestroy(im2); + gdImageDestroy(im3); + + fp = fopen("bug00181a.gif", "rb"); + if (!fp) { + gdTestErrorMsg("Cannot open <%s> for reading.\n", "bug00181a.gif"); + return 1; + } + im = gdImageCreateFromGif(fp); + fclose(fp); + if (!im) { + gdTestErrorMsg("Cannot create image from <%s>\n", "bug00181a.gif"); + return 1; + } + error = !im->interlace; + gdImageDestroy(im); + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00227.c b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00227.c new file mode 100644 index 00000000000..861006e7447 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/bug00227.c @@ -0,0 +1,67 @@ +#include <stdio.h> +#include <stdlib.h> +#include "gd.h" +#include "gdtest.h" + +#define WIDTH 150 +#define HEIGHT 1 +#define DELAY 100 +#define PROBE_SIZE 11 + +int main() +{ + FILE *fp; + gdImagePtr im0, im1, im2; + int i; + char *buf; + + /* generate a GIF animation */ + im0 = gdImageCreate(WIDTH, HEIGHT); + if (!im0) return 1; + for (i = 0; i < WIDTH; i++) { + int c = gdImageColorAllocate(im0, i, 0xff, 0xff); + gdImageSetPixel(im0, i, 0, c); + } + + fp = fopen("bug00227.gif", "wb"); + if (!fp) return 1; + + gdImageGifAnimBegin(im0, fp, 0, 0); + + gdImageGifAnimAdd(im0, fp, 1, 0, 0, DELAY, 1, NULL); + + im1 = gdImageCreate(WIDTH, HEIGHT); + if (!im1) return 1; + for (i = 0; i < WIDTH; i++) { + int c = gdImageColorAllocate(im1, i, 0x00, 0xff); + gdImageSetPixel(im1, i, 0, c); + } + gdImageGifAnimAdd(im1, fp, 1, 0, 0, DELAY, 1, im0); + + im2 = gdImageCreate(WIDTH, HEIGHT); + if (!im2) return 1; + for (i = 0; i < WIDTH; i++) { + int c = gdImageColorAllocate(im2, i, 0xff, 0x00); + gdImageSetPixel(im2, i, 0, c); + } + gdImageGifAnimAdd(im2, fp, 1, 0, 0, DELAY, 1, im1); + + gdImageGifAnimEnd(fp); + + fclose(fp); + + gdImageDestroy(im0); + gdImageDestroy(im1); + gdImageDestroy(im2); + + /* check the Global Color Table flag */ + fp = fopen("bug00227.gif", "rb"); + if (!fp) return 1; + buf = malloc(PROBE_SIZE); + if (!buf) return 1; + if (PROBE_SIZE != fread(buf, 1, PROBE_SIZE, fp)) return 1; + if (buf[PROBE_SIZE-1] & 0x80) return 1; + free(buf); + fclose(fp); + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/gif_im2im.c b/Build/source/libs/gd/libgd-2.1.1/tests/gif/gif_im2im.c new file mode 100644 index 00000000000..a5b0adbdb85 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/gif_im2im.c @@ -0,0 +1,66 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr src, dst; + int r, g, b; + void *p; + int size = 0; + int status = 0; + CuTestImageResult result = {0, 0}; + + src = gdImageCreate(100, 100); + if (src == NULL) { + printf("could not create src\n"); + return 1; + } + r = gdImageColorAllocate(src, 0xFF, 0, 0); + g = gdImageColorAllocate(src, 0, 0xFF, 0); + b = gdImageColorAllocate(src, 0, 0, 0xFF); + gdImageFilledRectangle(src, 0, 0, 99, 99, r); + gdImageRectangle(src, 20, 20, 79, 79, g); + gdImageEllipse(src, 70, 25, 30, 20, b); + +#define OUTPUT_GIF(name) do { \ + FILE *fp; \ + \ + fp = fopen("gif_im2im_" #name ".gif", "wb"); \ + if (fp) { \ + gdImageGif(name, fp); \ + fclose(fp); \ + } \ + } while (0) + + OUTPUT_GIF(src); + p = gdImageGifPtr(src, &size); + if (p == NULL) { + status = 1; + printf("p is null\n"); + goto door0; + } + if (size <= 0) { + status = 1; + printf("size is non-positive\n"); + goto door1; + } + + dst = gdImageCreateFromGifPtr(size, p); + if (dst == NULL) { + status = 1; + printf("could not create dst\n"); + goto door1; + } + OUTPUT_GIF(dst); + gdTestImageDiff(src, dst, NULL, &result); + if (result.pixels_changed > 0) { + status = 1; + printf("pixels changed: %d\n", result.pixels_changed); + } + gdImageDestroy(dst); +door1: + gdFree(p); +door0: + gdImageDestroy(src); + return status; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/gif/gif_null.c b/Build/source/libs/gd/libgd-2.1.1/tests/gif/gif_null.c new file mode 100644 index 00000000000..463d31ebaf6 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/gif/gif_null.c @@ -0,0 +1,14 @@ +#include "gd.h" + +int main() +{ + gdImagePtr im; + + im = gdImageCreateFromGif(NULL); + if (im != NULL) { + gdImageDestroy(im); + return 1; + } + gdImageGif(im, NULL); /* noop safely */ + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/CMakeLists.txt new file mode 100644 index 00000000000..9151f609173 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/CMakeLists.txt @@ -0,0 +1,14 @@ + +SET(TESTS_FILES + jpeg_im2im + jpeg_null + jpeg_read + jpeg_empty_file + jpeg_resolution +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/conv_test.jpeg b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/conv_test.jpeg Binary files differnew file mode 100644 index 00000000000..7283d1a4754 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/conv_test.jpeg diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/conv_test_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/conv_test_exp.png Binary files differnew file mode 100644 index 00000000000..1210f479aa6 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/conv_test_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/empty.jpeg b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/empty.jpeg new file mode 100644 index 00000000000..e69de29bb2d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/empty.jpeg diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_empty_file.c b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_empty_file.c new file mode 100644 index 00000000000..844dbf43d3e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_empty_file.c @@ -0,0 +1,31 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + FILE *fp; + char path[1024]; + + gdSetErrorMethod(gdSilence); + + sprintf(path, "%s/jpeg/empty.jpeg", GDTEST_TOP_DIR); + fp = fopen(path, "rb"); + if (!fp) { + printf("failed, cannot open file\n"); + return 1; + } + + im = gdImageCreateFromJpeg(fp); + fclose(fp); + + if (!im) { + return 0; + } else { + gdImageDestroy(im); + return 1; + } +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_im2im.c b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_im2im.c new file mode 100644 index 00000000000..89a72be7ffd --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_im2im.c @@ -0,0 +1,70 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr src, dst; + int r, g, b; + void *p; + int size = 0; + int status = 0; +#if 0 + CuTestImageResult result = {0, 0}; +#endif + + src = gdImageCreateTrueColor(100, 100); + if (src == NULL) { + printf("could not create src\n"); + return 1; + } + r = gdImageColorAllocate(src, 0xFF, 0, 0); + g = gdImageColorAllocate(src, 0, 0xFF, 0); + b = gdImageColorAllocate(src, 0, 0, 0xFF); + gdImageFilledRectangle(src, 0, 0, 99, 99, r); + gdImageRectangle(src, 20, 20, 79, 79, g); + gdImageEllipse(src, 70, 25, 30, 20, b); + +#define OUTPUT_JPEG(name) do { \ + FILE *fp; \ + \ + fp = fopen("jpeg_im2im_" #name ".jpeg", "wb"); \ + if (fp) { \ + gdImageJpeg(name, fp, 100); \ + fclose(fp); \ + } \ + } while (0) + + OUTPUT_JPEG(src); + p = gdImageJpegPtr(src, &size, 100); + if (p == NULL) { + status = 1; + printf("p is null\n"); + goto door0; + } + if (size <= 0) { + status = 1; + printf("size is non-positive\n"); + goto door1; + } + + dst = gdImageCreateFromJpegPtr(size, p); + if (dst == NULL) { + status = 1; + printf("could not create dst\n"); + goto door1; + } + OUTPUT_JPEG(dst); +#if 0 + gdTestImageDiff(src, dst, NULL, &result); + if (result.pixels_changed > 0) { + status = 1; + printf("pixels changed: %d\n", result.pixels_changed); + } +#endif + gdImageDestroy(dst); +door1: + gdFree(p); +door0: + gdImageDestroy(src); + return status; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_null.c b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_null.c new file mode 100644 index 00000000000..3b2caa68744 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_null.c @@ -0,0 +1,14 @@ +#include "gd.h" + +int main() +{ + gdImagePtr im; + + im = gdImageCreateFromJpeg(NULL); + if (im != NULL) { + gdImageDestroy(im); + return 1; + } + gdImageJpeg(im, NULL, 100); /* noop safely */ + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_read.c b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_read.c new file mode 100644 index 00000000000..64130ce125a --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_read.c @@ -0,0 +1,45 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" +#include <jpeglib.h> + +#ifdef _MSC_VER +# define snprintf _snprintf +#endif + +int main() +{ +#if defined(JPEG_LIB_VERSION_MAJOR) && JPEG_LIB_VERSION_MAJOR >= 8 + printf("skip, JPEG Major version too high (%i)\n", JPEG_LIB_VERSION_MAJOR); + return 0; +#else + gdImagePtr im; + FILE *fp; + char path[1024]; + + snprintf(path, sizeof(path)-1, "%s/jpeg/conv_test.jpeg", GDTEST_TOP_DIR); + fp = fopen(path, "rb"); + if (!fp) { + gdTestErrorMsg("failed, cannot open file: %s\n", path); + return 1; + } + + im = gdImageCreateFromJpeg(fp); + fclose(fp); + + if (im == NULL) { + gdTestErrorMsg("gdImageCreateFromJpeg failed.\n"); + return 1; + } + snprintf(path, sizeof(path), "%s/jpeg/conv_test_exp.png", GDTEST_TOP_DIR); + if (!gdAssertImageEqualsToFile(path, im)) { + gdTestErrorMsg("gdAssertImageEqualsToFile failed: <%s>.\n", path); + gdImageDestroy(im); + return 1; + } + + return 0; +#endif +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_resolution.c b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_resolution.c new file mode 100644 index 00000000000..386f5f3fee4 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/jpeg/jpeg_resolution.c @@ -0,0 +1,28 @@ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + void *data; + int size, red; + + im = gdImageCreate(100, 100); + gdImageSetResolution(im, 72, 300); + red = gdImageColorAllocate(im, 0xFF, 0x00, 0x00); + gdImageFilledRectangle(im, 0, 0, 99, 99, red); + data = gdImageJpegPtr(im, &size, 10); + gdImageDestroy(im); + + im = gdImageCreateFromJpegPtr(size, data); + gdFree(data); + if (!gdTestAssert(gdImageResolutionX(im) == 72) || !gdTestAssert(gdImageResolutionY(im) == 300)) { + gdTestErrorMsg("failed image resolution X (%d != 72) or Y (%d != 300)\n", gdImageResolutionX(im), gdImageResolutionY(im)); + gdImageDestroy(im); + return 1; + } + gdImageDestroy(im); + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/png/CMakeLists.txt new file mode 100644 index 00000000000..128b51df0ce --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/CMakeLists.txt @@ -0,0 +1,17 @@ + +SET(TESTS_FILES + png_im2im + png_null + png_resolution + bug00011 + bug00033 + bug00086 + bug00088 + bug00193 +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00011.c b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00011.c new file mode 100644 index 00000000000..865c87ea5cd --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00011.c @@ -0,0 +1,27 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + FILE *fp; + char path[2048]; + + sprintf(path, "%s/png/emptyfile", GDTEST_TOP_DIR); + fp = fopen(path, "rb"); + if (!fp) { + fprintf(stderr, "failed, cannot open file: %s\n", path); + return 1; + } + im = gdImageCreateFromPng(fp); + fclose(fp); + + if (!im) { + return 0; + } else { + return 1; + } +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00033.c b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00033.c new file mode 100644 index 00000000000..f7e90f0824c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00033.c @@ -0,0 +1,32 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + FILE *fp; + char path[1024]; + + gdSetErrorMethod(gdSilence); + + sprintf(path, "%s/png/bug00033.png", GDTEST_TOP_DIR); + fp = fopen(path, "rb"); + if (!fp) { + printf("failed, cannot open file <%s>\n", path); + return 1; + } + + im = gdImageCreateFromPng(fp); + fclose(fp); + + if (im) { + gdImageDestroy(im); + return 1; + } else { + return 0; + } + +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00033.png b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00033.png Binary files differnew file mode 100644 index 00000000000..73a7d6a3e77 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00033.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00086.c b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00086.c new file mode 100644 index 00000000000..ef9d43b2b56 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00086.c @@ -0,0 +1,33 @@ +/* $Id$ */ +/* id: gdbad3.c, Xavier Roche, May. 2007 */ +/* gcc gdbad3.c -o bad -lgd && ./bad */ + +#include <stdio.h> +#include <stdlib.h> +#include "gd.h" +#include "gdtest.h" + +static const unsigned char pngdata[93]; +int main(void) +{ + gdImagePtr im; + + gdSetErrorMethod(gdSilence); + + if ( ( im = gdImageCreateFromPngPtr(93, (char*) &pngdata[0]) ) == NULL) { + return 0; + } else { + fprintf(stderr, "failed!\n"); + gdImageDestroy(im); + return 1; + } + return 0; +} + +/* PNG data */ +static const unsigned char pngdata[93] = {137,80,78,71,13,10,26,10,0,0, + 0,13,73,72,68,82,0,0,0,120,0,0,0,131,8,6,0,0,0,70,49,223,8,0,0,0,6,98, + 75,71,68,0,255,0,255,0,255,160,189,167,147,0,0,0,9,112,72,89,115,0,0,92, + 70,0,0,92,70,1,20,148,67,65,0,0,0,9,118,112,65,103,0,0,0,120,0,0,0,131, + 0,226,13,249,45 +}; diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088.c b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088.c new file mode 100644 index 00000000000..78495aa4410 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088.c @@ -0,0 +1,44 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" + +int main() +{ + int error; + gdImagePtr im; + FILE *fp; + char path[1024]; + const char * files[2] = {"bug00088_1.png", "bug00088_2.png"}; + const char * files_exp[2] = {"bug00088_1_exp.png", "bug00088_2_exp.png"}; + + int i, cnt = 2; + error = 0; + + for (i = 0; i < cnt; i++) { + + sprintf(path, "%s/png/%s", GDTEST_TOP_DIR, files[i]); + fp = fopen(path, "rb"); + if (!fp) { + printf("failed, cannot open file <%s>\n", path); + return 1; + } + + im = gdImageCreateFromPng(fp); + fclose(fp); + + if (!im) { + error |= 1; + continue; + } + + sprintf(path, "%s/png/%s", GDTEST_TOP_DIR, files_exp[i]); + if (!gdAssertImageEqualsToFile(path, im)) { + error |= 1; + } + gdImageDestroy(im); + } + + return error; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088_1.png b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088_1.png Binary files differnew file mode 100644 index 00000000000..3f9a5c7d408 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088_1.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088_1_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088_1_exp.png Binary files differnew file mode 100644 index 00000000000..25ee05a93c9 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088_1_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088_2.png b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088_2.png Binary files differnew file mode 100644 index 00000000000..fa58ffe61c9 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088_2.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088_2_exp.png b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088_2_exp.png Binary files differnew file mode 100644 index 00000000000..a21c8408679 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00088_2_exp.png diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00193.c b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00193.c new file mode 100644 index 00000000000..67acf545f67 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/bug00193.c @@ -0,0 +1,43 @@ +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" +#include "gdtest.h" + +static gdImagePtr im; + +#define TERMINATE(ctx, status) do { \ + free(ctx); \ + gdImageDestroy(im); \ + exit(status); \ + } while (0) + +static void +failPutC(gdIOCtxPtr ctx, int c) +{ + (void)c; + TERMINATE(ctx, 1); +} + +static int +failPutBuf(gdIOCtxPtr ctx, const void * data, int size) +{ + (void)data; + (void)size; + TERMINATE(ctx, 1); + return -1; +} + +int main() +{ + gdIOCtxPtr ctx; + + gdSetErrorMethod(gdSilence); + + im = gdImageCreate(100, 100); + ctx = (gdIOCtxPtr)malloc(sizeof(gdIOCtx)); + ctx->putC = failPutC; + ctx->putBuf = failPutBuf; + gdImagePngCtx(im, ctx); + TERMINATE(ctx, 0); + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/emptyfile b/Build/source/libs/gd/libgd-2.1.1/tests/png/emptyfile new file mode 100644 index 00000000000..e69de29bb2d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/emptyfile diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/png_im2im.c b/Build/source/libs/gd/libgd-2.1.1/tests/png/png_im2im.c new file mode 100644 index 00000000000..bac5e13aeb7 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/png_im2im.c @@ -0,0 +1,66 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr src, dst; + int r, g, b; + void *p; + int size = 0; + int status = 0; + CuTestImageResult result = {0, 0}; + + src = gdImageCreate(100, 100); + if (src == NULL) { + printf("could not create src\n"); + return 1; + } + r = gdImageColorAllocate(src, 0xFF, 0, 0); + g = gdImageColorAllocate(src, 0, 0xFF, 0); + b = gdImageColorAllocate(src, 0, 0, 0xFF); + gdImageFilledRectangle(src, 0, 0, 99, 99, r); + gdImageRectangle(src, 20, 20, 79, 79, g); + gdImageEllipse(src, 70, 25, 30, 20, b); + +#define OUTPUT_PNG(name) do { \ + FILE *fp; \ + \ + fp = fopen("png_im2im_" #name ".png", "wb"); \ + if (fp) { \ + gdImagePng(name, fp); \ + fclose(fp); \ + } \ + } while (0) + + OUTPUT_PNG(src); + p = gdImagePngPtr(src, &size); + if (p == NULL) { + status = 1; + printf("p is null\n"); + goto door0; + } + if (size <= 0) { + status = 1; + printf("size is non-positive\n"); + goto door1; + } + + dst = gdImageCreateFromPngPtr(size, p); + if (dst == NULL) { + status = 1; + printf("could not create dst\n"); + goto door1; + } + OUTPUT_PNG(dst); + gdTestImageDiff(src, dst, NULL, &result); + if (result.pixels_changed > 0) { + status = 1; + printf("pixels changed: %d\n", result.pixels_changed); + } + gdImageDestroy(dst); +door1: + gdFree(p); +door0: + gdImageDestroy(src); + return status; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/png_null.c b/Build/source/libs/gd/libgd-2.1.1/tests/png/png_null.c new file mode 100644 index 00000000000..d3b5e6a963b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/png_null.c @@ -0,0 +1,17 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + + gdSetErrorMethod(gdSilence); + + im = gdImageCreateFromPng(NULL); + if (im != NULL) { + gdImageDestroy(im); + return 1; + } + gdImagePng(im, NULL); /* noop safely */ + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/png/png_resolution.c b/Build/source/libs/gd/libgd-2.1.1/tests/png/png_resolution.c new file mode 100644 index 00000000000..aed7545ba51 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/png/png_resolution.c @@ -0,0 +1,30 @@ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" + +int main() +{ + gdImagePtr im; + void *data; + int size, red; + + im = gdImageCreate(100, 100); + gdImageSetResolution(im, 72, 300); + red = gdImageColorAllocate(im, 0xFF, 0x00, 0x00); + gdImageFilledRectangle(im, 0, 0, 99, 99, red); + data = gdImagePngPtr(im, &size); + gdImageDestroy(im); + + im = gdImageCreateFromPngPtr(size, data); + gdFree(data); + + if (!gdTestAssert(gdImageResolutionX(im) == 72) || !gdTestAssert(gdImageResolutionY(im) == 300)) { + gdTestErrorMsg("failed image resolution X (%d != 72) or Y (%d != 300)\n", gdImageResolutionX(im), gdImageResolutionY(im)); + gdImageDestroy(im); + return 1; + } + + gdImageDestroy(im); + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/test_config.h.in b/Build/source/libs/gd/libgd-2.1.1/tests/test_config.h.in new file mode 100644 index 00000000000..bfa8127889f --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/test_config.h.in @@ -0,0 +1,3 @@ +/* Define the full path to the top src dir, required to get the path + * of each input data */ +#define GDTEST_TOP_DIR "@srcdir@" diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/tga/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/tga/CMakeLists.txt new file mode 100644 index 00000000000..48f9412fb09 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/tga/CMakeLists.txt @@ -0,0 +1,10 @@ + +SET(TESTS_FILES + tga_null +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/tga/tga_null.c b/Build/source/libs/gd/libgd-2.1.1/tests/tga/tga_null.c new file mode 100644 index 00000000000..f61078c32f5 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/tga/tga_null.c @@ -0,0 +1,13 @@ +#include "gd.h" + +int main() +{ + gdImagePtr im; + + im = gdImageCreateFromTga(NULL); + if (im != NULL) { + gdImageDestroy(im); + return 1; + } + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/tiff/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/tiff/CMakeLists.txt new file mode 100644 index 00000000000..da49800542e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/tiff/CMakeLists.txt @@ -0,0 +1,11 @@ + +SET(TESTS_FILES + tiff_im2im + tiff_null +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/tiff/tiff_im2im.c b/Build/source/libs/gd/libgd-2.1.1/tests/tiff/tiff_im2im.c new file mode 100644 index 00000000000..4b6136d4b92 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/tiff/tiff_im2im.c @@ -0,0 +1,70 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr src, dst; + int r, g, b; + void *p; + int size = 0; + int status = 0; +#if 0 + CuTestImageResult result = {0, 0}; +#endif + + src = gdImageCreate(100, 100); + if (src == NULL) { + printf("could not create src\n"); + return 1; + } + r = gdImageColorAllocate(src, 0xFF, 0, 0); + g = gdImageColorAllocate(src, 0, 0xFF, 0); + b = gdImageColorAllocate(src, 0, 0, 0xFF); + gdImageFilledRectangle(src, 0, 0, 99, 99, r); + gdImageRectangle(src, 20, 20, 79, 79, g); + gdImageEllipse(src, 70, 25, 30, 20, b); + +#define OUTPUT_TIFF(name) do { \ + FILE *fp; \ + \ + fp = fopen("tiff_im2im_" #name ".tiff", "wb"); \ + if (fp) { \ + gdImageTiff(name, fp); \ + fclose(fp); \ + } \ + } while (0) + + OUTPUT_TIFF(src); + p = gdImageTiffPtr(src, &size); + if (p == NULL) { + status = 1; + printf("p is null\n"); + goto door0; + } + if (size <= 0) { + status = 1; + printf("size is non-positive\n"); + goto door1; + } + + dst = gdImageCreateFromTiffPtr(size, p); + if (dst == NULL) { + status = 1; + printf("could not create dst\n"); + goto door1; + } + OUTPUT_TIFF(dst); +#if 0 + gdTestImageDiff(src, dst, NULL, &result); + if (result.pixels_changed > 0) { + status = 1; + printf("pixels changed: %d\n", result.pixels_changed); + } +#endif + gdImageDestroy(dst); +door1: + gdFree(p); +door0: + gdImageDestroy(src); + return status; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/tiff/tiff_null.c b/Build/source/libs/gd/libgd-2.1.1/tests/tiff/tiff_null.c new file mode 100644 index 00000000000..ccaade7498f --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/tiff/tiff_null.c @@ -0,0 +1,14 @@ +#include "gd.h" + +int main() +{ + gdImagePtr im; + + im = gdImageCreateFromTiff(NULL); + if (im != NULL) { + gdImageDestroy(im); + return 1; + } + gdImageTiff(im, NULL); /* noop safely */ + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/wbmp/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/wbmp/CMakeLists.txt new file mode 100644 index 00000000000..531933a8558 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/wbmp/CMakeLists.txt @@ -0,0 +1,11 @@ + +SET(TESTS_FILES + wbmp_im2im + wbmp_null +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/wbmp/wbmp_im2im.c b/Build/source/libs/gd/libgd-2.1.1/tests/wbmp/wbmp_im2im.c new file mode 100644 index 00000000000..826c7fa953c --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/wbmp/wbmp_im2im.c @@ -0,0 +1,64 @@ +#include "gd.h" +#include "gdtest.h" + +int main() +{ + gdImagePtr src, dst; + int b; + void *p; + int size = 0; + int status = 0; + CuTestImageResult result = {0, 0}; + + src = gdImageCreate(100, 100); + if (src == NULL) { + printf("could not create src\n"); + return 1; + } + gdImageColorAllocate(src, 0xFF, 0xFF, 0xFF); /* allocate white for background color */ + b = gdImageColorAllocate(src, 0, 0, 0); + gdImageRectangle(src, 20, 20, 79, 79, b); + gdImageEllipse(src, 70, 25, 30, 20, b); + +#define OUTPUT_WBMP(name) do { \ + FILE *fp; \ + \ + fp = fopen("wbmp_im2im_" #name ".wbmp", "wb"); \ + if (fp) { \ + gdImageWBMP(name, 1, fp); \ + fclose(fp); \ + } \ + } while (0) + + OUTPUT_WBMP(src); + p = gdImageWBMPPtr(src, &size, 1); + if (p == NULL) { + status = 1; + printf("p is null\n"); + goto door0; + } + if (size <= 0) { + status = 1; + printf("size is non-positive\n"); + goto door1; + } + + dst = gdImageCreateFromWBMPPtr(size, p); + if (dst == NULL) { + status = 1; + printf("could not create dst\n"); + goto door1; + } + OUTPUT_WBMP(dst); + gdTestImageDiff(src, dst, NULL, &result); + if (result.pixels_changed > 0) { + status = 1; + printf("pixels changed: %d\n", result.pixels_changed); + } + gdImageDestroy(dst); +door1: + gdFree(p); +door0: + gdImageDestroy(src); + return status; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/wbmp/wbmp_null.c b/Build/source/libs/gd/libgd-2.1.1/tests/wbmp/wbmp_null.c new file mode 100644 index 00000000000..d70f38d01bf --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/wbmp/wbmp_null.c @@ -0,0 +1,14 @@ +#include "gd.h" + +int main() +{ + gdImagePtr im; + + im = gdImageCreateFromWBMP(NULL); + if (im != NULL) { + gdImageDestroy(im); + return 1; + } + gdImageWBMP(im, 0, NULL); /* noop safely */ + return 0; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/xpm/CMakeLists.txt b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/CMakeLists.txt new file mode 100644 index 00000000000..e0a789c807b --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/CMakeLists.txt @@ -0,0 +1,12 @@ + +SET(TESTS_FILES + bug00166 + bug00185 + color_name +) + +FOREACH(test_name ${TESTS_FILES}) + add_executable(${test_name} "${test_name}.c") + target_link_libraries (${test_name} gdTest) + add_test(NAME ${test_name} COMMAND ${test_name}) +ENDFOREACH(test_name) diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00166.c b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00166.c new file mode 100644 index 00000000000..2ffd6af25a2 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00166.c @@ -0,0 +1,29 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + char path[1024]; + int c, result; + + sprintf(path, "%s/xpm/bug00166.xpm", GDTEST_TOP_DIR); + im = gdImageCreateFromXpm(path); + if (!im) { + return 2; + } + c = gdImageGetPixel(im, 1, 1); + if (gdImageRed(im, c) == 0xAA + && gdImageGreen(im, c) == 0xBB + && gdImageBlue(im, c) == 0xCC) { + result = 0; + } else { + result = 1; + } + gdImageDestroy(im); + return result; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00166.xpm b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00166.xpm new file mode 100644 index 00000000000..90c6cd387e7 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00166.xpm @@ -0,0 +1,12 @@ +/* XPM */ +static char * a[] = { +/* width height colors cpp */ +"4 4 3 1", +" c None", +"@ c #abc", +". c #def", +/* pixels */ +" .. ", +".@@.", +".@@.", +" .. "}; diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00185.c b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00185.c new file mode 100644 index 00000000000..2dda809cc96 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00185.c @@ -0,0 +1,25 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" + +/* To check memory leaks, run such as 'valgrind --leak-check=full ./bug00185' */ +int +main() +{ + gdImagePtr im; + char path[1024]; + + sprintf(path, "%s/xpm/bug00185.xpm", GDTEST_TOP_DIR); + im = gdImageCreateFromXpm(path); + if (!im) return 1; + gdImageDestroy(im); + + sprintf(path, "%s/xpm/bug00185_damaged.xpm", GDTEST_TOP_DIR); + im = gdImageCreateFromXpm(path); + if (!im) return 0; + gdImageDestroy(im); + + return 2; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00185.xpm b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00185.xpm new file mode 100644 index 00000000000..bb7cd7975a8 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00185.xpm @@ -0,0 +1,12 @@ +/* XPM */ +static char * a[] = { +/* width height colors cpp */ +"4 4 3 1", +" c None", +"x c #ff00ff", +". c #ff0000", +/* pixels */ +" ..x", +".xxx", +"xxx.", +"x.. "}; diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00185_damaged.xpm b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00185_damaged.xpm new file mode 100644 index 00000000000..b0c7d61be5e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/bug00185_damaged.xpm @@ -0,0 +1,11 @@ +/* XPM */ +static char * a[] = { +/* width height colors cpp */ +"4 4 3 1", +" c None", +"x c #ff00ff", +". c #ff0000", +/* pixels */ +" ..x", +"xxx.", +"x.. " diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/xpm/color_name.c b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/color_name.c new file mode 100644 index 00000000000..22481785a83 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/color_name.c @@ -0,0 +1,29 @@ +/* $Id$ */ +#include "gd.h" +#include <stdio.h> +#include <stdlib.h> +#include "gdtest.h" + +int +main(void) +{ + gdImagePtr im; + char path[1024]; + int c, result; + + sprintf(path, "%s/xpm/color_name.xpm", GDTEST_TOP_DIR); + im = gdImageCreateFromXpm(path); + if (!im) { + return 2; + } + c = gdImageGetPixel(im, 2, 2); + if (gdImageRed(im, c) == 0xFF + && gdImageGreen(im, c) == 0xFF + && gdImageBlue(im, c) == 0x0) { + result = 0; + } else { + result = 1; + } + gdImageDestroy(im); + return result; +} diff --git a/Build/source/libs/gd/libgd-2.1.1/tests/xpm/color_name.xpm b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/color_name.xpm new file mode 100644 index 00000000000..4733789245d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/tests/xpm/color_name.xpm @@ -0,0 +1,17 @@ +/* XPM */ +static char *color_name = { +"3 5 6 1", + +" c None", +"A c AliceBlue", +"b c blue", +"c c cyan", +"w c wheat", +"y c yellow", + +" A ", +"AbA", +"yby", +"ycy", +"wcw", +}; diff --git a/Build/source/libs/gd/libgd-2.1.1/thumbs.bat b/Build/source/libs/gd/libgd-2.1.1/thumbs.bat new file mode 100755 index 00000000000..6e94aa42a50 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/thumbs.bat @@ -0,0 +1,37 @@ +@echo off
+rem thumbs wrapper for windows; see main file for details
+
+
+rem find bash from git
+rem assumes git is in [gitdir]\cmd
+rem and msys in [gitdir]\bin
+
+for %%i in (git.exe) do set gitexe=%%~$PATH:i
+pushd "%gitexe%\..\..\bin"
+set bashdir=%cd%
+popd
+set path=%bashdir%;%path%
+
+
+rem copy all known env vars to bash
+
+setlocal enableDelayedExpansion
+set exports=
+
+for %%i in (tbs_conf tbs_arch tbs_tools tbs_static_runtime) do (
+ if not [!%%i!]==[] (
+ set exports=!exports!export %%i=!%%i!;
+ )
+)
+
+rem copy dep settings
+
+for %%i in (zlib libjpeg_turbo libpng libtiff freetype libiconv) do (
+ for %%j in (repo incdir libdir built) do (
+ if not [!tbsd_%%i_%%j!]==[] (
+ set exports=!exports!export tbsd_%%i_%%j=!tbsd_%%i_%%j!;
+ )
+ )
+)
+
+bash -c "%exports%./thumbs.sh %*"
diff --git a/Build/source/libs/gd/libgd-2.1.1/thumbs.sh b/Build/source/libs/gd/libgd-2.1.1/thumbs.sh new file mode 100755 index 00000000000..f898ef50f74 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/thumbs.sh @@ -0,0 +1,320 @@ +#!/bin/bash + +# THe Ultimate Make Bash Script +# Used to wrap build scripts for easy dep +# handling and multiplatform support + + +# Basic usage on *nix: +# export tbs_arch=x86 +# ./thumbs.sh make + + +# On Win (msvc 2013): +# C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall x86_amd64 +# SET tbs_tools=msvc12 +# thumbs make + +# On Win (mingw32): +# SET path=C:\mingw32\bin;%path% +# SET tbs_tools=mingw +# SET tbs_arch=x86 +# thumbs make + + +# Global settings are stored in env vars +# Should be inherited + +[ $tbs_conf ] || export tbs_conf=Release +[ $tbs_arch ] || export tbs_arch=x64 +[ $tbs_tools ] || export tbs_tools=gnu +[ $tbs_static_runtime ] || export tbs_static_runtime=0 + +[ $tbs_gd_png ] || export tbs_gd_png=1 +[ $tbs_gd_jpeg ] || export tbs_gd_jpeg=1 +[ $tbs_gd_freetype ] || export tbs_gd_freetype=1 +[ $tbs_gd_tiff ] || export tbs_gd_tiff=1 + + +# tbsd_* contains dep related settings +# tbsd_[name]_* contains settings specific to the dep +# name should match the repo name + +# deps contains a map of what should be built/used +# keep the keys in sync ... no assoc arrays on msys :/ +# targ contains a target for each dep (default=empty str) +# post is executed after each thumbs dep build +# ^ used for copying/renaming any libs you need - uses eval + +zname=zlib.lib +jname=jpeg.lib +pname=png.lib +tname=tiff.lib +fname=freetype.lib + +if [ $tbs_tools = gnu -o $tbs_tools = mingw ] +then + zname=libz.a + jname=libjpeg.a + pname=libpng.a + tname=libtiff.a + fname=libfreetype.a +fi + +deps=() +targ=() +post=() + +[ $tbsd_zlib_repo ] || export tbsd_zlib_repo="https://github.com/imazen/zlib" +[ $tbsd_libpng_repo ] || export tbsd_libpng_repo="https://github.com/imazen/libpng" +[ $tbsd_libjpeg_turbo_repo ] || export tbsd_libjpeg_turbo_repo="https://github.com/imazen/libjpeg-turbo libjpeg_turbo" +[ $tbsd_libtiff_repo ] || export tbsd_libtiff_repo="https://github.com/imazen/libtiff" +[ $tbsd_freetype_repo ] || export tbsd_freetype_repo="https://github.com/imazen/freetype" + +if [[ "$OSTYPE" == "darwin"* ]]; then cp="rsync" +else cp="cp" +fi + +deps+=(zlib); targ+=(zlibstatic) +post+=("$cp -u \$(./thumbs.sh list_slib) ../../deps/$zname") + +if [ $tbs_gd_png -gt 0 ]; then + deps+=(libpng); targ+=(png16_static) + post+=("$cp -u \$(./scripts/thumbs.sh list_slib) ../../deps/$pname") +fi + +if [ $tbs_gd_jpeg -gt 0 ]; then + deps+=(libjpeg_turbo); targ+=(jpeg_static) + post+=("for lib in \$(./thumbs.sh list_slib); do [ -f \$lib ] && $cp -u \$lib ../../deps/$jname; done") +fi + +if [ $tbs_gd_tiff -gt 0 ]; then + ttarg="libtiff/tiff_static" + [ $tbs_tools = gnu -o $tbs_tools = mingw ] && ttarg=tiff_static + deps+=(libtiff); targ+=($ttarg) + post+=("$cp -u \$(./thumbs.sh list_slib) ../../deps/$tname") +fi + +if [ $tbs_gd_freetype -gt 0 ]; then + deps+=(freetype); targ+=("freetype_static") + post+=("$cp -u \$(./thumbs.sh list_slib) ../../deps/$fname") +fi + + + +# ----------- +# dep processor + +process_deps() +{ + mkdir build_deps + mkdir deps + cd build_deps + + for key in "${!deps[@]}" + do + dep=${deps[$key]} + i_dep_repo="tbsd_${dep}_repo" + i_dep_incdir="tbsd_${dep}_incdir" + i_dep_libdir="tbsd_${dep}_libdir" + i_dep_built="tbsd_${dep}_built" + + [ ${!i_dep_built} ] || export "${i_dep_built}=0" + + if [ ${!i_dep_built} -eq 0 ] + then + git clone ${!i_dep_repo} --depth 1 + cd $dep || exit 1 + + thumbs="./thumbs.sh" + [ ! -f $thumbs ] && thumbs=$(find . -name thumbs.sh -maxdepth 2) + + $thumbs make ${targ[$key]} || exit 1 + + # copy any includes and do poststep + $cp -u -r $($thumbs list_inc) ../../deps + eval ${post[$key]} + + # look in both local and parent dep dirs + export "${i_dep_incdir}=../../deps;deps" + export "${i_dep_libdir}=../../deps;deps" + export "${i_dep_built}=1" + + cd .. + fi + done + + export "${i_dep_incdir}=../../deps/freetype;deps/freetype" + + cd .. +} + +# ----------- +# constructs dep dirs for cmake + +postproc_deps() +{ + cm_inc= + cm_lib= + + for dep in "${deps[@]}" + do + i_dep_incdir="tbsd_${dep}_incdir" + i_dep_libdir="tbsd_${dep}_libdir" + + cm_inc="${!i_dep_incdir};$cm_inc" + cm_lib="${!i_dep_libdir};$cm_lib" + done + + cm_args+=(-DCMAKE_LIBRARY_PATH=$cm_lib) + cm_args+=(-DCMAKE_INCLUDE_PATH=$cm_inc) +} + +# ----------- + +if [ $# -lt 1 ] +then + echo "" + echo " Usage : ./thumbs [command]" + echo "" + echo " Commands:" + echo " make - builds everything" + echo " check - runs tests" + echo " clean - removes build files" + echo " list - echo paths to any interesting files" + echo " space separated; relative" + echo " list_bin - echo binary paths" + echo " list_inc - echo lib include files" + echo " list_slib - echo static lib path" + echo " list_dlib - echo dynamic lib path" + echo "" + exit +fi + +# ----------- + +upper() +{ + echo $1 | tr [:lower:] [:upper:] +} + +# Local settings + +l_inc="./src/gd.h ./src/gd_io.h ./src/gdfx.h" +l_slib= +l_dlib= +l_bin= +list= + +make= +c_flags= +cm_tools= +cm_args=(-DCMAKE_BUILD_TYPE=$tbs_conf) +cm_args+=(-DBUILD_TEST=1) +cm_args+=(-DENABLE_PNG=$tbs_gd_png) +cm_args+=(-DENABLE_JPEG=$tbs_gd_jpeg) +cm_args+=(-DENABLE_FREETYPE=$tbs_gd_freetype) +cm_args+=(-DENABLE_TIFF=$tbs_gd_tiff) + +target= +[ $2 ] && target=$2 + +# ----------- + +case "$tbs_tools" in +msvc12) + cm_tools="Visual Studio 12" + [ "$target" = "" ] && mstrg="GD.sln" || mstrg="$target.vcxproj" + make="msbuild.exe $mstrg //p:Configuration=$tbs_conf //v:m" + + l_slib="./build/Bin/$tbs_conf/libgd_static.lib" + l_dlib="./build/Bin/$tbs_conf/libgd.lib" + l_bin="./build/Bin/$tbs_conf/libgd.dll" + list="$l_bin $l_slib $l_dlib $l_inc" ;; +gnu) + cm_tools="Unix Makefiles" + c_flags+=" -fPIC" + make="make $target" + l_slib="./build/Bin/libgd.a" + l_dlib="./build/Bin/libgd.so" + l_bin="$l_dlib" + list="$l_slib $l_dlib $l_inc" ;; +mingw) + cm_tools="MinGW Makefiles" + make="mingw32-make $target" + c_flags+=" -fkeep-inline-functions" + + # allow sh in path; some old cmake/mingw bug? + cm_args+=(-DCMAKE_SH=) + + l_slib="./build/Bin/liblibgd.a" + l_dlib="./build/Bin/liblibgd.dll.a" + l_bin="./build/Bin/liblibgd.dll" + list="$l_bin $l_slib $l_dlib $l_inc" ;; + +*) echo "Tool config not found for $tbs_tools" + exit 1 ;; +esac + +# ----------- + +case "$tbs_arch" in +x64) + [ $tbs_tools = msvc12 ] && cm_tools="$cm_tools Win64" + [ $tbs_tools = gnu -o $tbs_tools = mingw ] && c_flags+=" -m64" ;; +x86) + [ $tbs_tools = gnu -o $tbs_tools = mingw ] && c_flags+=" -m32" ;; + +*) echo "Arch config not found for $tbs_arch" + exit 1 ;; +esac + +# ----------- + +if [ $tbs_static_runtime -gt 0 ] +then + [ $tbs_tools = msvc12 ] && c_flags+=" /MT" + [ $tbs_tools = gnu ] && cm_args+=(-DCMAKE_SHARED_LINKER_FLAGS="-static-libgcc -static-libstdc++") + [ $tbs_tools = mingw ] && cm_args+=(-DCMAKE_SHARED_LINKER_FLAGS="-static") +fi + +# ----------- + +case "$1" in +make) + process_deps + postproc_deps + + mkdir build + cd build + + cm_args+=(-DCMAKE_C_FLAGS_$(upper $tbs_conf)="$c_flags") + cm_args+=(-DCMAKE_CXX_FLAGS_$(upper $tbs_conf)="$c_flags") + + cmake -G "$cm_tools" "${cm_args[@]}" .. || exit 1 + $make || exit 1 + + cd .. + ;; + +check) + cd build + ctest -C $tbs_conf . || exit 1 + cd .. + ;; + +clean) + rm -rf deps + rm -rf build_deps + rm -rf build + ;; + +list) echo $list;; +list_bin) echo $l_bin;; +list_inc) echo $l_inc;; +list_slib) echo $l_slib;; +list_dlib) echo $l_dlib;; + +*) echo "Unknown command $1" + exit 1;; +esac diff --git a/Build/source/libs/gd/libgd-2.1.1/windows/Makefile.vc b/Build/source/libs/gd/libgd-2.1.1/windows/Makefile.vc new file mode 100644 index 00000000000..f17c50d1bd1 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/windows/Makefile.vc @@ -0,0 +1,183 @@ +# To build locally get a copy of the dependancies (https://github.com/imazen/gd-win-dependencies) +# Then run 'nmake /f windows\Makefile.vc' in MS dev console +# To build tests as well 'nmake /f windows\Makefile.vc all' +# To build tests and execute them 'nmake /f windows\Makefile.vc check' + +CC=cl +LD=link +LB=lib + + +!IFNDEF PLATFORM +PLATFORM=x86 +!ENDIF +# detect x64 cross-compiler env +!IF "$(PREFERREDTOOLARCHITECTURE)" == "x64" +PLATFORM=x64 +!ENDIF +PLATFORM=$(PLATFORM:X=x) + + +BUILD_DIR=build_msvc12_$(PLATFORM) +GD_DLL=libgd.dll +GD_LIB=libgd_a.lib + +SDR=$(BUILD_DIR)\obj^\ +TDR=$(BUILD_DIR)\tests^\ +TARGETDLL=$(BUILD_DIR)\$(GD_DLL) +TARGETLIB=$(BUILD_DIR)\$(GD_LIB) + +OBJECTS=$(SDR)gd.obj $(SDR)gd_color.obj $(SDR)gd_color_map.obj $(SDR)gd_transform.obj $(SDR)gdfx.obj $(SDR)gd_security.obj $(SDR)gd_gd.obj $(SDR)gd_gd2.obj $(SDR)gd_io.obj $(SDR)gd_io_dp.obj $(SDR)gd_gif_in.obj $(SDR)gd_gif_out.obj $(SDR)gd_io_file.obj $(SDR)gd_io_ss.obj $(SDR)gd_jpeg.obj $(SDR)gd_png.obj $(SDR)gd_ss.obj $(SDR)gd_topal.obj $(SDR)gd_wbmp.obj $(SDR)gdcache.obj $(SDR)gdfontg.obj $(SDR)gdfontl.obj $(SDR)gdfontmb.obj $(SDR)gdfonts.obj $(SDR)gdfontt.obj $(SDR)gdft.obj $(SDR)gdhelpers.obj $(SDR)gdkanji.obj $(SDR)gdtables.obj $(SDR)gdxpm.obj $(SDR)wbmp.obj $(SDR)gd_filter.obj $(SDR)gd_nnquant.obj $(SDR)gd_rotate.obj $(SDR)gd_matrix.obj $(SDR)gd_interpolation.obj $(SDR)gd_crop.obj $(SDR)webpimg.obj $(SDR)gd_webp.obj $(SDR)gd_tiff.obj $(SDR)gd_tga.obj $(SDR)gd_bmp.obj $(SDR)gd_xbm.obj $(SDR)gd_color_match.obj $(SDR)gd_version.obj $(SDR)gd_filename.obj +TESTS=bmp\bmp_im2im bmp\bmp_null freetype\bug00132 gd\gd_im2im gd\gd_null gd\gd_num_colors gd\gd_versiontest gd2\gd2_empty_file gd2\gd2_im2im gd2\gd2_null gd2\gd2_read gdimagearc\bug00079 gdimagecolorclosest\gdimagecolorclosest gdimagecolordeallocate\gdimagecolordeallocate gdimagecolorexact\gdimagecolorexact gdimagecolorreplace\gdimagecolorreplace gdimagecolorresolve\gdimagecolorresolve gdimagecolortransparent\gdimagecolortransparent gdimagecopy\bug00007 gdimagecopy\bug00081 gdimagecopyrotated\bug00020 gdimagefile\gdnametest gdimagefill\bug00002_1 gdimagefill\bug00002_2 gdimagefill\bug00002_3 gdimagefill\bug00002_4 gdimagefilledellipse\bug00010 gdimagefilledellipse\bug00191 gdimagefilledpolygon\bug00100 gdimagefilledpolygon\gdimagefilledpolygon0 gdimagefilledpolygon\gdimagefilledpolygon1 gdimagefilledpolygon\gdimagefilledpolygon2 gdimagefilledpolygon\gdimagefilledpolygon3 gdimagefilledrectangle\bug00004 gdimagefilledrectangle\bug00078 gdimagefilledrectangle\bug00106_gdimagefilledrectangle gdimagefilltoborder\bug00037 gdimagefilter\gdCopyBlurred gdimageline\bug00072 gdimageline\bug00077 gdimageline\bug00111 gdimageline\gdImageAALine_thickness gdimageline\gdimageline_aa gdimageline\gdimageline_aa_outofrange gdimageline\gdimageline_bug5 gdimageopenpolygon\gdimageopenpolygon0 gdimageopenpolygon\gdimageopenpolygon1 gdimageopenpolygon\gdimageopenpolygon2 gdimageopenpolygon\gdimageopenpolygon3 gdimagepixelate\gdimagepixelate gdimagepolygon\gdimagepolygon0 gdimagepolygon\gdimagepolygon1 gdimagepolygon\gdimagepolygon2 gdimagepolygon\gdimagepolygon3 gdimagerectangle\bug00003 gdimagerectangle\bug00106_gdimagerectangle gdimagerotate\bug00067 gdimagerotate\php_bug_64898 gdimagescatterex\bug00208_1 gdimagescatterex\bug00208_2 gdimagesetpixel\bug00186 gdimagesetpixel\gdeffectmultiply gdimagesetpixel\gdeffectoverlay gdimagestringft\gdimagestringft_bbox gdimagestringftex\gdimagestringftex_returnfontpathname gdinterpolatedscale\gdModesAndPalettes gdinterpolatedscale\gdTrivialResize gdnewfilectx\gdnewfilectx_null gdtiled\bug00032 gif\bug00005 gif\bug00005_2 gif\bug00006 gif\bug00060 gif\bug00066 gif\bug00181 gif\bug00227 gif\gif_im2im gif\gif_null jpeg\jpeg_empty_file jpeg\jpeg_im2im jpeg\jpeg_null jpeg\jpeg_read jpeg\jpeg_resolution png\bug00011 png\bug00033 png\bug00086 png\bug00088 png\bug00193 png\png_im2im png\png_null png\png_resolution tga\tga_null +#tiff\tiff_im2im tiff\tiff_null wbmp\wbmp_im2im wbmp\wbmp_null xpm\bug00166 xpm\bug00185 xpm\color_name + +LIBS=kernel32.lib ole32.lib user32.lib advapi32.lib shell32.lib ws2_32.lib Dnsapi.lib Gdi32.Lib +LIBS_GD=turbojpeg-static.lib freetype_a.lib libpng_a.lib libiconv_a.lib zlib_a.lib + +INCLUDES=/Isrc /Igd-win-dependencies\$(PLATFORM)\include -Igd-win-dependencies\$(PLATFORM)\include\libjpeg-turbo -Igd-win-dependencies\$(PLATFORM)\include\libpng15 -Igd-win-dependencies\$(PLATFORM)\include\freetype /Itests /Itests\gdtest + +LDFLAGS=/nologo /nodefaultlib:libcmt /libpath:gd-win-dependencies\$(PLATFORM)\lib /MACHINE:$(PLATFORM) + +CFLAGS=/nologo /O2 /Qvec-report:1 /MD /TC\ + /DWIN32=1\ + /D_WIN32=1\ + /DMSWIN32=1\ + /DBGDWIN32=1\ + /DHAVE_FT2BUILD_H=1\ + /DHAVE_GD_H=1\ + /DHAVE_PNG_H=1\ + /DHAVE_ICONV_H=1\ + /DHAVE_GD_BUNDLED=1\ + /DHAVE_LIBFREETYPE=1\ + /DHAVE_LIBJPEG=1\ + /DHAVE_LIBPNG=1\ + /DHAVE_LIBZ=1\ + $(INCLUDES) + +# /DHAVE_LIBXPM + +# These flags are not present in this fork of libgd (they may be used in php's): +# /DHAVE_GD_WBMP +# /DHAVE_GD_GIF_READ=1\ +# /DHAVE_GD_GIF_CREATE=1\ +# /DHAVE_GD_GD2=1\ +# /DHAVE_GDIMAGECOLORRESOLVE=1\ +# /DHAVE_GD_IMAGESETBRUSH=1\ +# /DHAVE_GD_IMAGESETTILE=1\ +# /DHAVE_GD_FONTCACHESHUTDOWN=1\ +# /DHAVE_GD_FONTMUTEX=1\ +# /DHAVE_GD_STRINGFTEX=1\ +# /DHAVE_GD_STRINGTTF=1\ +# /DHAVE_GD_FREETYPE=1\ +# /DHAVE_LIBGD13=1\ +# /DHAVE_LIBGD15=1\ +# /DHAVE_LIBGD20=1\ +# /DHAVE_LIBGD204=1\ +# /DHAVE_COLORCLOSESTHWB\ +# /DUSE_GD_IMGSTRTTF\ +# /DUSE_GD_IOCTX\ +# /DHAVE_GD_JPG\ +# /DHAVE_GD_PNG\ +# /DHAVE_GD_DYNAMIC_CTX_EX=1\ +# /DHAVE_XPM\ +# /DHAVE_GD_XBM\ +# /DHAVE_GD_XPM\ +# /DHAVE_XPM_H=1\ + +# These flags may be set wrong; not sure of precise purpose +# HAVE_GD_BUNDLED +# NDEBUG + + + + + +TEST_CFLAGS=$(CFLAGS) /FItest_config.h +TEST_LDFLAGS=$(LDFLAGS) $(SDR)gdtest.obj $(BUILD_DIR)\libgd.lib +TEST_CONFIG=tests\test_config.h +TEST_LIST=$(TDR)testlist.txt +TEST_MK=$(TDR)Maketests.vc + + + +# generate test makefile from TESTS macro + +!IF [if not exist $(BUILD_DIR) mkdir $(BUILD_DIR)] +!ENDIF +!IF [if not exist $(TDR) mkdir $(TDR)] +!ENDIF +!IF [@copy NUL $(TEST_MK) > nul] +!ENDIF +!IF [@for %F in ($(TESTS)) do @echo TEST_EXES=$(TDR)%~nF.exe ^$(TEST_EXES) >> $(TEST_MK)] +!ENDIF +!IF [@for %F in ($(TESTS)) do @echo $(SDR)%~nF.obj: tests\%F.c; @^$(CC) ^$(TEST_CFLAGS) /c ^$** /Fo:^$@ >> $(TEST_MK)] +!ENDIF +!IF [@for %F in ($(TESTS)) do @echo $(TDR)%~nF.exe: $(SDR)%~nF.obj; @$(LD) $(TEST_LDFLAGS) ^$** /out:^$@ >> $(TEST_MK)] +!ENDIF +TEST_OBJS=$(TEST_EXES:tests=obj) +TEST_OBJS=$(TEST_OBJS:exe=obj) + + + + + + +# pseudotargets + +build_libs: make_dirs $(TARGETDLL) $(TARGETLIB) +all: build_libs build_tests +check: all run_tests + +clean: + @if exist $(SDR) rd $(SDR) /s /q + @if exist $(TDR) rd $(TDR) /s /q + @if exist $(BUILD_DIR)\*.exe del $(BUILD_DIR)\*.exe /q + @if exist tests\test_config.h del tests\test_config.h /q + + + + +# helpers + +make_dirs: + @if not exist $(BUILD_DIR) mkdir $(BUILD_DIR) + @if not exist $(SDR) mkdir $(SDR) + +run_tests: + @windows\run_tests + + + + +# libgd + +$(TARGETDLL): $(OBJECTS) + @$(LD) /DLL /OUT:$@ $(OBJECTS) $(LIBS_GD) $(LIBS) $(LDFLAGS) + +$(TARGETLIB): $(OBJECTS) + @$(LB) /OUT:$@ $(OBJECTS) $(LDFLAGS) + +{src\}.c{$(SDR)}.obj:: + @$(CC) $(CFLAGS) /c $< /Fo$(SDR) + + + + +# tests + +!INCLUDE $(TEST_MK) + +build_tests: $(TEST_LIST) $(SDR)gdtest.obj $(TEST_EXES) + +$(SDR)gdtest.obj: $(TARGETDLL) $(TEST_CONFIG) tests\gdtest\gdtest.c + @$(CC) $(CFLAGS) /c tests\gdtest\gdtest.c /Fo$(SDR)gdtest.obj + +$(TEST_CONFIG): + @echo #define GDTEST_TOP_DIR "$(MAKEDIR:\=\\)\\tests" > tests\test_config.h + @echo #define snprintf _snprintf >> tests\test_config.h + +$(TEST_LIST): $(TARGETDLL) + @if not exist $(TDR) mkdir $(TDR) + @copy $(TARGETDLL) $(TDR)$(GD_DLL) + @copy NUL $(TDR)testlist.txt + @for %%F in ($(TESTS)) do @echo %%F >> $(TDR)testlist.txt
\ No newline at end of file diff --git a/Build/source/libs/gd/libgd-2.1.1/windows/libgd.rc b/Build/source/libs/gd/libgd-2.1.1/windows/libgd.rc new file mode 100644 index 00000000000..dfe6ff0aa78 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/windows/libgd.rc @@ -0,0 +1,59 @@ +/* This is a template RC file. + * $Id$ + * Do not edit with MSVC */ +#ifdef APSTUDIO_INVOKED +# error dont edit with MSVC +#endif + +#include "winres.h" +#include "../gd.h" + +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) + +#ifdef WANT_LOGO +0 ICON gdlib.ico +#endif + +//Version +VS_VERSION_INFO VERSIONINFO + FILEVERSION GD_MAJOR_VERSION,GD_MINOR_VERSION,GD_RELEASE_VERSION,0 + PRODUCTVERSION GD_MAJOR_VERSION,GD_MINOR_VERSION,GD_RELEASE_VERSION,0 + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS VS_FF_DEBUG +#else + FILEFLAGS 0x0L +#endif + FILEOS VOS__WINDOWS32 + FILETYPE VFT_DLL + FILESUBTYPE VFT2_UNKNOWN +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "Comments", "Thanks to Thomas Boutell" "\0" + VALUE "CompanyName", "LIBGD Development Team\0" + VALUE "FileDescription", "LIBGD" "\0" + VALUE "FileVersion", GD_VERSION_STRING "\0" + VALUE "InternalName", "bgd.dll" "\0" + VALUE "LegalCopyright", "Copyright © 1997-2008 Thomas Boutell, Pierre A. Joye and contributors, see COPYING\0" + VALUE "LegalTrademarks", "Thomas Boutell, Pierre A. Joye and contributors\0" + VALUE "OriginalFilename", "bgd.dll" "\0" + VALUE "PrivateBuild", "\0" + VALUE "ProductName", "LIBGD dynamic link library" "\0" + VALUE "SpecialBuild", "win32" "\0" + VALUE "URL", "http://www.libgd.org/" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + +#ifdef MC_INCLUDE +#include MC_INCLUDE +#endif + diff --git a/Build/source/libs/gd/libgd-2.1.1/windows/msys/Makefile b/Build/source/libs/gd/libgd-2.1.1/windows/msys/Makefile new file mode 100644 index 00000000000..7e7f155885e --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/windows/msys/Makefile @@ -0,0 +1,143 @@ + +# Simple makefile for building and testing libgd under MSYS/MinGW on +# Windows + + +# The version +LIBVER=3.0.1 + +# Misc. config flags. +CDEFS=-DHAVE_ERRNO_H -DHAVE_ICONV -DHAVE_ICONV_H \ +-DHAVE_ICONV_T_DEF -DHAVE_INTTYPES_H -DHAVE_LIMITS_H -DHAVE_STDDEF_H \ +-DHAVE_STDINT_H -DHAVE_STDLIB_H -DHAVE_VISIBILITY -DICONV_CONST + +# GnuWin32 libs should all be installed in one place. +GNUDIR=/c/tools/GnuWin32 +GNUINC=-I$(GNUDIR)/include +GNULIB=-L$(GNUDIR)/lib +GNUDLL=$(GNUDIR)/bin/ + +# Various optional components. Comment-out the ones you don't have +# and edit the paths and options as needed if you do. The default +# assumes GnuWin32 packages installed in /c/Program Files/GnuWin32. +JPEG_D=-DHAVE_LIBJPEG +JPEG_L=-ljpeg +JPEG_I=$(GNUINC) +JPEG_LIBDIR=$(GNULIB) +JPEG_DLLDIR=$(GNUDLL) + +PNG_D=-DHAVE_LIBPNG +PNG_L=-lpng +PNG_I= #$(GNUINC) +PNG_LIBDIR= #$(GNULIB) +PNG_DLLDIR= #$(GNUDLL) + +TIFF_D=-DHAVE_LIBTIFF +TIFF_L=-ltiff +TIFF_I= #$(GNUINC) +TIFF_LIBDIR= #$(GNULIB) +TIFF_DLLDIR= #$(GNUDLL) + +LIBZ_D=-DHAVE_LIBZ +LIBZ_L=-lz +LIBZ_I= #$(GNUINC) +LIBZ_LIBDIR= #$(GNULIB) +LIBZ_DLLDIR= #$(GNUDLL) + +# LIBXPM_D=-DHAVE_LIBXPM +# LIBXPM_L=-lxpm +# LIBXPM_I= #$(GNUINC) +# LIBXPM_LIBDIR= #$(GNULIB) + +FREETYPE_D=-DHAVE_LIBFREETYPE -DHAVE_FT2BUILD_H +FREETYPE_L=-lfreetype +FREETYPE_I=$(GNUINC)/freetype2/ +FREETYPE_LIBDIR= #$(GNULIB) +FREETYPE_DLLDIR= #$(GNUDLL) + +# FONTCONFIG_D=-DHAVE_LIBFONTCONFIG +# FONTCONFIG_L= +# FONTCONFIG_I= +# FONTCONFIG_LIBDIR= + +ALL_D=$(FREETYPE_D) $(JPEG_D) $(PNG_D) $(TIFF_D) $(LIBZ_D) $(LIBXPM_D) +ALL_L=$(FREETYPE_L) $(JPEG_L) $(PNG_L) $(TIFF_L) $(LIBZ_L) $(LIBXPM_L) +ALL_I=$(FREETYPE_I) $(JPEG_I) $(PNG_I) $(TIFF_I) $(LIBZ_I) $(LIBXPM_I) +ALL_LIBDIR=$(FREETYPE_LIBDIR) $(JPEG_LIBDIR) $(PNG_LIBDIR) $(TIFF_LIBDIR) \ + $(LIBZ_LIBDIR) $(LIBXPM_LIBDIR) +ALL_DLLDIR=$(FREETYPE_DLLDIR) $(JPEG_DLLDIR) $(PNG_DLLDIR) $(TIFF_DLLDIR) \ + $(LIBZ_DLLDIR) $(LIBXPM_DLLDIR) + +# We need libiconv for internationalization. We default to static +# linking because that reduces the number of dependencies. However, +# libiconv is released under the GNU GPL which may impose extra +# restrictions on redistribution. +LIBICONV=/c/MinGW/lib/libiconv.a +#LIBICONV=-liconv + + +DEFS=$(CDEFS) $(ALL_D) +INCLUDES=$(ALL_I) + +CC=gcc +CFLAGS=-g -O2 -I. -std=gnu99 -fvisibility=hidden -static-libgcc \ + -D_WIN32 -DBGDWIN32 $(DEFS) $(INCLUDES) + +LD=gcc +LDFLAGS=-g -O2 -fvisibility=hidden -static-libgcc $(ALL_LIBDIR) +LIBS=$(ALL_L) $(LIBICONV) + +ZIP=zip -j9 +DIST=libgd-win.zip + +# Get this list from c files in libgd_la_SOURCES in Makefile.mk +SRC=gd.c gd_color.c gd_color_map.c gd_transform.c gdfx.c \ +gd_security.c gd_gd.c gd_gd2.c gd_io.c gd_io_dp.c gd_gif_in.c \ +gd_gif_out.c gd_io_file.c gd_io_ss.c gd_jpeg.c gd_png.c gd_ss.c \ +gd_topal.c gd_wbmp.c gdcache.c gdfontg.c gdfontl.c gdfontmb.c \ +gdfonts.c gdfontt.c gdft.c gdhelpers.c gdkanji.c gdtables.c gdxpm.c \ +wbmp.c gd_filter.c gd_nnquant.c gd_rotate.c gd_matrix.c \ +gd_interpolation.c gd_crop.c webpimg.c gd_webp.c gd_tiff.c gd_tga.c \ +gd_bmp.c gd_xbm.c gd_color_match.c gd_version.c gd_filename.c + +OBJ=$(SRC:.c=.o) + +TARGETBASE=libgd +TARGET=$(TARGETBASE).dll +TARGET_A=$(TARGETBASE).a + +all: + (cd ../../src; make -f ../windows/msys/Makefile $(TARGET)) + +# BUG: this sucks in all the DLLs in the lib installation directory, +# including those you may not need. +dist: all + (cd ../..; $(ZIP) $(DIST) src/*.dll src/*.a $$(for d in $(ALL_DLLDIR); do echo $$d/*.dll; done | sort -u) ) + + +clean: + -rm ../../$(DIST) + (cd ../../src; rm -f *.dll *.a $(OBJ) deps.mk; true) + +check: all + bash run_tests.sh "$(GNUDIR)/bin" "$(INCLUDES)" + +deps.mk: + [ -f gd.h ] # Sanity check: we're in src/, right? + gcc -MM $(DEFS) $(INCLUDES) $(SRC) > deps.mk + +$(TARGET): $(OBJ) + gcc -shared -o $(TARGET) $(LDFLAGS) -Wl,--out-implib,$(TARGET_A) \ + $(OBJ) $(LIBS) + +include deps.mk + + + + + + + + + + diff --git a/Build/source/libs/gd/libgd-2.1.1/windows/msys/README.MSYS.md b/Build/source/libs/gd/libgd-2.1.1/windows/msys/README.MSYS.md new file mode 100644 index 00000000000..601802dd8e0 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/windows/msys/README.MSYS.md @@ -0,0 +1,65 @@ + +# MSYS Fallback Makefile + +This is a simple, straightforward Makefile for building LibGD with +MinGW on MSYS (or possibly Cygwin). It is here for anyone who doesn't +want to deal with autotools or CMake on Windows or who can't get +either of them working on their particular setup. + +Note that this Makefile only builds the library and test cases; the +standalone utilities are ignored. If you need those, you'll need to +use one of the other build systems (or add them yourself.) + +## To build LibGD: + +1. Install MinGW and MSYS (see <http://www.mingw.org/wiki/Getting_Started>). + You will need to install zip and unzip as well as the 32-bit C compiler + and related tools. + +2. Install LibJpeg, LibPng, LibTiff, Zlib and FreeType from + <http://gnuwin32.sourceforge.net> and install them all in + `c:/tools/GnuWin32/`. (You can get these libraries from other + places and/or install them in different locations, but you'll need to + edit the Makefile accordingly if you do.) + +3. Skip ahead to the next step. If that doesn't work, edit the + Makefile to fix what went wrong. Things to try include: + * Ensure SRC contains an up-to-date list of source files. (Take a + look at libgd_la_SOURCES src/Makefile.am for a reference.) + * Ensure that the paths and #defines for unsupported libraries + are commented out. They're nicely grouped into clusters to + simplify that. + +4. `cd` to this directory and type: + + make + make check + + If both commands succeed, you're done. (Note that some of the + testcases will fail, just because they test features not enabled + here. This is fine. As long as most tests pass, you're probably + okay.) + +5. Type + + make dist + + This will create libgd-win.zip, a zip file containing the new + library and its dependants. Note that this step may pick up extra + DLLs; it sweeps up all of the DLLs in the directories pointed to + by *_DLLDIR Makefile variables. + + Alternately, you can copy the lib (in src/) to wherever it needs + to go. + + +## Stuff that Doesn't Work + +* LibXpm: It's probably nothing serious, just more trouble than it's + worth. +* LibFontconfig: I couldn't find Windows binaries for it anywhere + reputable. + + + + diff --git a/Build/source/libs/gd/libgd-2.1.1/windows/msys/deps.mk b/Build/source/libs/gd/libgd-2.1.1/windows/msys/deps.mk new file mode 100644 index 00000000000..9b531b3103d --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/windows/msys/deps.mk @@ -0,0 +1 @@ +# Nothing to see here. (But it shuts up make.) diff --git a/Build/source/libs/gd/libgd-2.1.1/windows/msys/run_tests.sh b/Build/source/libs/gd/libgd-2.1.1/windows/msys/run_tests.sh new file mode 100755 index 00000000000..22de13c4036 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/windows/msys/run_tests.sh @@ -0,0 +1,67 @@ +#!/bin/bash + +set -e + +# Parameters +DLLPATH_EXTRA=$1 # Path to supporting DLLs +CFLAGS_EXTRA=$2 # Extra C flags + + +LOG=run_tests.log + +CFLAGS="-g -Igdtest/ -I. -I../src/ -D_WIN32 $CFLAGS_EXTRA" +LDFLAGS='-L../src -llibgd' +DLLPATH=../src:$DLLPATH_EXTRA + +function run_gcc { + if msg=`gcc $* 2>&1`; then + true + else + echo "COMMAND: gcc $*" >> $LOG + echo $msg >> $LOG + false + fi +} + +# Switch to the working directory +export PATH=$PATH:$DLLPATH +cd ../../tests + +# Initial setup +echo "Setting up..." +[ -f $LOG ] && rm -f $LOG +[ -f test_config.h ] || echo '#define GDTEST_TOP_DIR "."' > test_config.h +run_gcc -c $CFLAGS gdtest/gdtest.c + + +echo "Running tests:" +count=0 +failures=0 +compile_failures=0 +for test in `find . -name \*.c | grep -v '^./gdtest'`; do + count=`expr $count + 1` + + exe=${test%.c}.exe + if run_gcc -o $exe $CFLAGS $LDFLAGS $test gdtest.o; then + true; + else + echo "COMPILE_FAIL: $test" + compile_failures=`expr $compile_failures + 1` + continue + fi + + echo "Running $exe:" >> $LOG + if $exe 2>&1 >> $LOG; then + echo "PASS: $test" + else + failures=`expr $failures + 1` + echo "FAIL: $test" + fi + echo >> $LOG +done + +echo "$failures failures and $compile_failures compile failures out of $count tests." +echo "Error messages in $LOG" + + + diff --git a/Build/source/libs/gd/libgd-2.1.1/windows/readme.md b/Build/source/libs/gd/libgd-2.1.1/windows/readme.md new file mode 100644 index 00000000000..8753b704723 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/windows/readme.md @@ -0,0 +1,11 @@ +# Building on Windows with Visual Studio 2013 + +Open the VS2013 x64 Native Tools Command Prompt. 2012 will *not* work. +Change to the gd-libgd folder. +git clone https://github.com/imazen/gd-win-dependencies into the folder. +Run +nmake /f windows/Makefile.vc all +nmake /f windows/Makefile.vc check + +Before rebuilding, run: +nmake /f windows/Makefile.vc clean
\ No newline at end of file diff --git a/Build/source/libs/gd/libgd-2.1.1/windows/run_tests.bat b/Build/source/libs/gd/libgd-2.1.1/windows/run_tests.bat new file mode 100755 index 00000000000..5dadb059407 --- /dev/null +++ b/Build/source/libs/gd/libgd-2.1.1/windows/run_tests.bat @@ -0,0 +1,38 @@ +@echo off +setlocal EnableDelayedExpansion +if [%PLATFORM%]==[] set PLATFORM=x86 +if [%PREFERREDTOOLARCHITECTURE%]==[x64] set PLATFORM=x64 +set PLATFORM=%PLATFORM:X=x% + +if exist build_msvc12_%PLATFORM%\tests (cd build_msvc12_%PLATFORM%\tests) else ( + if exist ..\build_%PLATFORM%\tests (cd ..\build_msvc12_%PLATFORM%\tests) else ( + echo unable to find test dir + exit /b 1 + ) +) + + + +for /f %%T in (testlist.txt) do ( + set test=%%T + set output=test: !test!.................................................................... + + set target=%%~nT.exe + if not exist !target! SET result=NotFound + call !target! && (SET result=Passed) || (SET result=Failed) + + rem > last_test.out 2> last_test.err + rem set /p testerr=<last_test.err + rem set /p testout=<last_test.out + + echo !output:~0,70!!result! + + rem if defined testerr echo error: !testerr! + rem if defined testout echo msg: !testout! + + if defined APPVEYOR ( + appveyor AddTest "!test! %PLATFORM%" -Outcome !result! -Framework Custom -Filename %%~nT.exe -Duration 0 + ) +) + +exit /b 0
\ No newline at end of file |