--- a/jdk/make/com/sun/Makefile Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/com/sun/Makefile Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -44,7 +44,7 @@
SUBDIRS_management = jmx
SUBDIRS_desktop = image
SUBDIRS_enterprise = crypto/provider jndi \
- org xml rowset net/httpserver
+ org rowset net/httpserver
SUBDIRS_misc = $(SCRIPT_SUBDIR) tracing servicetag nio demo
# Omit mirror since it's built with the apt tool.
--- a/jdk/make/com/sun/xml/Makefile Mon Mar 21 16:55:14 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-#
-# Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
-# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
-#
-# This code is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 2 only, as
-# published by the Free Software Foundation. Oracle designates this
-# particular file as subject to the "Classpath" exception as provided
-# by Oracle in the LICENSE file that accompanied this code.
-#
-# This code 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
-# version 2 for more details (a copy is included in the LICENSE file that
-# accompanied this code).
-#
-# You should have received a copy of the GNU General Public License version
-# 2 along with this work; if not, write to the Free Software Foundation,
-# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
-#
-# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
-# or visit www.oracle.com if you need additional information or have any
-# questions.
-#
-
-#
-# Makefile for building packages under javax.xml
-#
-
-BUILDDIR = ../../..
-PACKAGE = com.sun.xml
-PRODUCT = xml
-include $(BUILDDIR)/common/Defs.gmk
-
-#
-# Files to compile
-#
-AUTO_FILES_JAVA_DIRS = com/sun/activation \
- org/relaxng/datatype
-
-#
-# Rules
-#
-include $(BUILDDIR)/common/Classes.gmk
--- a/jdk/make/common/Defs-linux.gmk Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/common/Defs-linux.gmk Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -107,6 +107,8 @@
LDFLAGS_COMMON_sparcv9 += -m64 -mcpu=v9
CFLAGS_REQUIRED_sparc += -m32 -mcpu=v9
LDFLAGS_COMMON_sparc += -m32 -mcpu=v9
+CFLAGS_REQUIRED_arm += -fsigned-char -D_LITTLE_ENDIAN
+CFLAGS_REQUIRED_ppc += -fsigned-char -D_BIG_ENDIAN
ifeq ($(ZERO_BUILD), true)
CFLAGS_REQUIRED = $(ZERO_ARCHFLAG)
ifeq ($(ZERO_ENDIANNESS), little)
@@ -143,11 +145,9 @@
#
# Misc compiler options
#
-ifeq ($(ARCH),ppc)
- CFLAGS_COMMON = -fsigned-char
-else # ARCH
+ifneq ($(ARCH),ppc)
CFLAGS_COMMON = -fno-strict-aliasing
-endif # ARCH
+endif
PIC_CODE_LARGE = -fPIC
PIC_CODE_SMALL = -fpic
GLOBAL_KPIC = $(PIC_CODE_LARGE)
@@ -219,8 +219,19 @@
# The environment variable LD_LIBRARY_PATH will over-ride these runpaths.
# Try: 'readelf -d lib*.so' to see these settings in a library.
#
- LDFLAGS_COMMON += -Xlinker -z -Xlinker origin -Xlinker -rpath -Xlinker \$$ORIGIN
- LDFLAGS_COMMON += $(LD_RUNPATH_EXTRAS:%=-Xlinker -z -Xlinker origin -Xlinker -rpath -Xlinker \$$ORIGIN/%)
+ Z_ORIGIN_FLAG/sparc = -Xlinker -z -Xlinker origin
+ Z_ORIGIN_FLAG/i586 = -Xlinker -z -Xlinker origin
+ Z_ORIGIN_FLAG/amd64 = -Xlinker -z -Xlinker origin
+ Z_ORIGIN_FLAG/ia64 = -Xlinker -z -Xlinker origin
+ Z_ORIGIN_FLAG/arm =
+ Z_ORIGIN_FLAG/ppc =
+ Z_ORIGIN_FLAG/zero = -Xlinker -z -Xlinker origin
+
+ LDFLAG_Z_ORIGIN = $(Z_ORIGIN_FLAG/$(ARCH_FAMILY))
+
+ LDFLAGS_COMMON += $(LDFLAG_Z_ORIGIN) -Xlinker -rpath -Xlinker \$$ORIGIN
+ LDFLAGS_COMMON += $(LD_RUNPATH_EXTRAS:%=$(LDFLAG_Z_ORIGIN) -Xlinker -rpath -Xlinker \$$ORIGIN/%)
+
endif
EXTRA_LIBS += -lc
@@ -315,7 +326,6 @@
override LIBTHREAD =
override MOOT_PRIORITIES = true
override NO_INTERRUPTIBLE_IO = true
-override OPENWIN_HOME = /usr/X11R6
ifeq ($(ARCH), amd64)
override OPENWIN_LIB = $(OPENWIN_HOME)/lib64
else
@@ -359,3 +369,9 @@
INCLUDE_SA = true
endif
+ifdef CROSS_COMPILE_ARCH
+ # X11 headers are not under /usr/include
+ OTHER_CFLAGS += -I$(OPENWIN_HOME)/include
+ OTHER_CXXFLAGS += -I$(OPENWIN_HOME)/include
+ OTHER_CPPFLAGS += -I$(OPENWIN_HOME)/include
+endif
--- a/jdk/make/common/Defs.gmk Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/common/Defs.gmk Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -116,6 +116,36 @@
include $(JDK_TOPDIR)/make/common/Defs-$(PLATFORM).gmk
#
+# Cross-compilation Settings
+#
+ifdef CROSS_COMPILE_ARCH
+ # Can't run the tools we just built
+ USE_ONLY_BOOTDIR_TOOLS = true
+
+ # When cross-compiling CC generates code for the target, but
+ # some parts of the build generate C code that has to be compiled
+ # and executed on the build host - HOST_CC is the 'local' compiler.
+ # For linux the default is /usr/bin/gcc; other platforms need to
+ # set it explicitly
+ ifeq ($(PLATFORM), linux)
+ ifndef HOST_CC
+ HOST_CC = $(USRBIN_PATH)gcc
+ endif
+ endif
+else
+ # Must set HOST_CC if not already set
+ ifndef HOST_CC
+ HOST_CC = $(CC)
+ endif
+endif
+
+# Reset the VM name for client-only builds
+ifdef BUILD_CLIENT_ONLY
+ VM_NAME = client
+endif
+
+
+#
# Freetype logic is applicable to OpenJDK only
#
ifdef OPENJDK
@@ -334,8 +364,7 @@
INCLUDES = -I. -I$(CLASSHDRDIR) \
$(patsubst %,-I%,$(subst $(CLASSPATH_SEPARATOR), ,$(VPATH.h))) $(OTHER_INCLUDES)
-OTHER_CPPFLAGS = $(INCLUDES)
-
+OTHER_CPPFLAGS += $(INCLUDES)
#
# vpaths. These are the default locations searched for source files.
@@ -466,9 +495,11 @@
#
# Tool flags
#
+# EXTRA_CFLAGS are used to define cross-compilation options
+#
ASFLAGS = $(ASFLAGS_$(VARIANT)) $(ASFLAGS_COMMON) $(OTHER_ASFLAGS)
-CFLAGS = $(CFLAGS_$(VARIANT)/BYFILE) $(CFLAGS_COMMON) $(OTHER_CFLAGS)
-CXXFLAGS = $(CXXFLAGS_$(VARIANT)/BYFILE) $(CXXFLAGS_COMMON) $(OTHER_CXXFLAGS)
+CFLAGS = $(CFLAGS_$(VARIANT)/BYFILE) $(CFLAGS_COMMON) $(OTHER_CFLAGS) $(EXTRA_CFLAGS)
+CXXFLAGS = $(CXXFLAGS_$(VARIANT)/BYFILE) $(CXXFLAGS_COMMON) $(OTHER_CXXFLAGS) $(EXTRA_CFLAGS)
CPPFLAGS = $(CPPFLAGS_$(VARIANT)) $(CPPFLAGS_COMMON) $(OTHER_CPPFLAGS) \
$(DEFINES) $(OPTIONS:%=-D%)
LDFLAGS = $(LDFLAGS_$(VARIANT)) $(LDFLAGS_COMMON) $(OTHER_LDFLAGS)
--- a/jdk/make/common/Program.gmk Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/common/Program.gmk Mon Mar 21 16:57:18 2011 -0700
@@ -83,7 +83,7 @@
endif
endif
ifeq ($(PLATFORM), linux)
- LDFLAGS += -Wl,-z -Wl,origin
+ LDFLAGS += $(LDFLAG_Z_ORIGIN)
LDFLAGS += -Wl,--allow-shlib-undefined
LDFLAGS += -Wl,-rpath -Wl,\$$ORIGIN/../lib/$(LIBARCH)/jli
LDFLAGS += -Wl,-rpath -Wl,\$$ORIGIN/../jre/lib/$(LIBARCH)/jli
--- a/jdk/make/common/internal/Defs-jaxws.gmk Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/common/internal/Defs-jaxws.gmk Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 1997, 2007, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -55,6 +55,7 @@
com/sun/tools/internal/xjc \
com/sun/tools/internal/ws \
com/sun/tools/internal/jxc \
+ org/relaxng \
META-INF/services/com.sun.mirror.apt.AnnotationProcessorFactory \
- META-INF/services/com.sun.tools.xjc.Plugin
+ META-INF/services/com.sun.tools.internal.xjc.Plugin
--- a/jdk/make/common/shared/Defs-linux.gmk Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/common/shared/Defs-linux.gmk Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -102,6 +102,14 @@
COMPILER_PATH =/usr/bin/
endif
+# OPENWIN_HOME: path to where the X11 environment is installed.
+# NOTE: Must end with / so that it could be empty, allowing PATH usage.
+ifneq ($(ALT_OPENWIN_HOME),)
+ OPENWIN_HOME :=$(call PrefixPath,$(ALT_OPENWIN_HOME))
+else
+ OPENWIN_HOME =/usr/X11R6/
+endif
+
# DEVTOOLS_PATH: for other tools required for building (such as zip, etc.)
# NOTE: Must end with / so that it could be empty, allowing PATH usage.
ifneq "$(origin ALT_DEVTOOLS_PATH)" "undefined"
@@ -181,6 +189,7 @@
# Macro to check it's input file for banned dependencies and verify the
# binary built properly. Relies on process exit code.
+ifndef CROSS_COMPILE_ARCH
define binary_file_verification # binary_file
( \
$(ECHO) "Checking for mapfile use in: $1" && \
@@ -193,4 +202,10 @@
( $(READELF) -d $1 | $(EGREP) 'NEEDED|RUNPATH|RPATH' ) \
)
endef
-
+else
+define binary_file_verification
+( \
+ $(ECHO) "Skipping binary file verification for cross-compile build" \
+)
+endef
+endif
\ No newline at end of file
--- a/jdk/make/common/shared/Defs-solaris.gmk Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/common/shared/Defs-solaris.gmk Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -190,6 +190,7 @@
# Macro to check it's input file for banned dependencies and verify the
# binary built properly. Relies on process exit code.
+ifndef CROSS_COMPILE_ARCH
define binary_file_verification # binary_file
( \
$(ECHO) "Checking for mapfile use in: $1" && \
@@ -202,4 +203,10 @@
( $(DUMP) -L -v $1 | $(EGREP) 'NEEDED|RUNPATH|RPATH' ) \
)
endef
-
+else
+define binary_file_verification
+( \
+ $(ECHO) "Skipping binary file verification for cross-compile build" \
+)
+endef
+endif
\ No newline at end of file
--- a/jdk/make/common/shared/Defs-utils.gmk Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/common/shared/Defs-utils.gmk Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -68,9 +68,23 @@
endif
# Utilities
+ifdef CROSS_COMPILE_ARCH
+ AR = $(COMPILER_PATH)ar
+ AS = $(COMPILER_PATH)as
+ LD = $(COMPILER_PATH)ld
+ MCS = $(COMPILER_PATH)mcs
+ NM = $(COMPILER_PATH)nm
+ STRIP = $(COMPILER_PATH)strip
+else
+ AR = $(UTILS_CCS_BIN_PATH)ar
+ AS = $(UTILS_CCS_BIN_PATH)as
+ LD = $(UTILS_CCS_BIN_PATH)ld
+ MCS = $(UTILS_CCS_BIN_PATH)mcs
+ NM = $(UTILS_CCS_BIN_PATH)nm
+ STRIP = $(UTILS_CCS_BIN_PATH)strip
+endif
+
ADB = $(UTILS_COMMAND_PATH)adb
-AR = $(UTILS_CCS_BIN_PATH)ar
-AS = $(UTILS_CCS_BIN_PATH)as
BASENAME = $(UTILS_COMMAND_PATH)basename
BZIP2 = $(UTILS_COMMAND_PATH)bzip2
CAT = $(UTILS_COMMAND_PATH)cat
@@ -99,19 +113,16 @@
ID = $(UTILS_COMMAND_PATH)id
ISAINFO = $(UTILS_COMMAND_PATH)isainfo
KSH = $(UTILS_COMMAND_PATH)ksh
-LD = $(UTILS_CCS_BIN_PATH)ld
LDD = $(UTILS_USR_BIN_PATH)ldd
LEX = $(UTILS_CCS_BIN_PATH)lex
LN = $(UTILS_COMMAND_PATH)ln
LS = $(UTILS_COMMAND_PATH)ls
-MCS = $(UTILS_CCS_BIN_PATH)mcs
M4 = $(UTILS_CCS_BIN_PATH)m4
MKDIR = $(UTILS_COMMAND_PATH)mkdir
MKSINFO = $(UTILS_COMMAND_PATH)mksinfo
MSGFMT = $(UTILS_USR_BIN_PATH)msgfmt
MV = $(UTILS_COMMAND_PATH)mv
NAWK = $(UTILS_USR_BIN_PATH)nawk
-NM = $(UTILS_CCS_BIN_PATH)nm
PKGMK = $(UTILS_COMMAND_PATH)pkgmk
PRINTF = $(UTILS_USR_BIN_PATH)printf
PWD = $(UTILS_COMMAND_PATH)pwd
@@ -123,7 +134,6 @@
SH = $(UTILS_COMMAND_PATH)sh
SHOWREV = $(UTILS_USR_BIN_PATH)showrev
SORT = $(UTILS_COMMAND_PATH)sort
-STRIP = $(UTILS_CCS_BIN_PATH)strip
TAIL = $(UTILS_USR_BIN_PATH)tail
TAR = $(UTILS_COMMAND_PATH)tar
TEST = $(UTILS_USR_BIN_PATH)test
@@ -186,14 +196,16 @@
# Intrinsic unix command, with backslash-escaped character interpretation
ECHO = /bin/echo -e
# These are really in UTILS_USR_BIN_PATH on Linux
- AR = $(UTILS_USR_BIN_PATH)ar
- AS = $(UTILS_USR_BIN_PATH)as
- LD = $(UTILS_USR_BIN_PATH)ld
+ ifndef CROSS_COMPILE_ARCH
+ AR = $(UTILS_USR_BIN_PATH)ar
+ AS = $(UTILS_USR_BIN_PATH)as
+ LD = $(UTILS_USR_BIN_PATH)ld
+ MCS = $(UTILS_USR_BIN_PATH)mcs
+ NM = $(UTILS_USR_BIN_PATH)nm
+ STRIP = $(UTILS_USR_BIN_PATH)strip
+ endif
LEX = $(UTILS_USR_BIN_PATH)lex
- MCS = $(UTILS_USR_BIN_PATH)mcs
M4 = $(UTILS_USR_BIN_PATH)m4
- NM = $(UTILS_USR_BIN_PATH)nm
- STRIP = $(UTILS_USR_BIN_PATH)strip
YACC = $(UTILS_USR_BIN_PATH)yacc
endif
--- a/jdk/make/common/shared/Defs-versions.gmk Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/common/shared/Defs-versions.gmk Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -138,11 +138,15 @@
endif
REQUIRED_COMPILER_NAME = Sun Studio 12 Update 1
REQUIRED_COMPILER_VERSION = SS12u1
- ifeq ($(CC_VERSION),sun)
- REQUIRED_CC_VER = 5.10
- endif
- ifeq ($(CC_VERSION),gcc)
- REQUIRED_CC_VER = 3.4.3
+ # Cross-compilation compiler versions are target specific
+ # so don't set a required version if cross-compiling
+ ifndef CROSS_COMPILE_ARCH
+ ifeq ($(CC_VERSION),sun)
+ REQUIRED_CC_VER = 5.10
+ endif
+ ifeq ($(CC_VERSION),gcc)
+ REQUIRED_CC_VER = 3.4.3
+ endif
endif
REQUIRED_GCC_VER = 2.95.2
endif
@@ -158,11 +162,15 @@
REQUIRED_COMPILER_NAME = GCC4
REQUIRED_COMPILER_VERSION = GCC4
REQUIRED_GCC_VER = 2.95
- ifeq ($(CC_VERSION),gcc)
- REQUIRED_CC_VER = 4.3.0
- endif
- ifeq ($(CC_VERSION),sun)
- REQUIRED_CC_VER = 5.10
+ # Cross-compilation compiler versions are target specific
+ # so don't set a required version if cross-compiling
+ ifndef CROSS_COMPILE_ARCH
+ ifeq ($(CC_VERSION),gcc)
+ REQUIRED_CC_VER = 4.3.0
+ endif
+ ifeq ($(CC_VERSION),sun)
+ REQUIRED_CC_VER = 5.10
+ endif
endif
endif
--- a/jdk/make/common/shared/Platform.gmk Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/common/shared/Platform.gmk Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 1997, 20010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -155,7 +155,11 @@
ifeq ($(SYSTEM_UNAME), Linux)
PLATFORM = linux
# Arch and OS name/version
- mach := $(shell uname -m)
+ ifdef CROSS_COMPILE_ARCH
+ mach := $(CROSS_COMPILE_ARCH)
+ else
+ mach := $(shell uname -m)
+ endif
archExpr = case "$(mach)" in \
i[3-9]86) \
echo i586 \
@@ -192,11 +196,13 @@
ARCH=sparcv9
endif
else
- # i586 is 32-bit, amd64 is 64-bit
+ # Most archs are 32-bit
ifndef ARCH_DATA_MODEL
- ifeq ($(ARCH), i586)
- ARCH_DATA_MODEL=32
- else
+ ARCH_DATA_MODEL=32
+ ifeq ($(ARCH), amd64)
+ ARCH_DATA_MODEL=64
+ endif
+ ifeq ($(ARCH), ia64)
ARCH_DATA_MODEL=64
endif
endif
--- a/jdk/make/common/shared/Sanity-Settings.gmk Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/common/shared/Sanity-Settings.gmk Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -104,7 +104,11 @@
endif
ALL_SETTINGS+=$(call addOptionalSetting,COMPILER_NAME)
ALL_SETTINGS+=$(call addOptionalSetting,COMPILER_VERSION)
-ALL_SETTINGS+=$(call addRequiredVersionSetting,CC_VER)
+ifdef REQUIRED_CC_VER
+ ALL_SETTINGS+=$(call addRequiredVersionSetting,CC_VER)
+else
+ ALL_SETTINGS+=$(call addOptionalSetting,CC_VER)
+endif
ifeq ($(PLATFORM),solaris)
ifeq ($(ARCH_DATA_MODEL), 32)
ifndef OPENJDK
--- a/jdk/make/common/shared/Sanity.gmk Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/common/shared/Sanity.gmk Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -220,7 +220,7 @@
sane-ant_version \
sane-zip_version \
sane-unzip_version \
- sane-msvcrt_path \
+ sane-msvcrt_path \
sane-freetype
######################################################
@@ -279,6 +279,12 @@
" $(YOU_ARE_USING) ARCH_DATA_MODEL=$(ARCH_DATA_MODEL). \n" \
"" >> $(ERROR_FILE) ; \
fi
+ifdef BUILD_CLIENT_ONLY
+ @if [ "$(ARCH_DATA_MODEL)" != 32 ]; then \
+ $(ECHO) "WARNING: You have requested BUILD_CLIENT_ONLY in a 64-bit build.\n" \
+ "" >> $(WARNING_FILE) ; \
+ fi
+endif
######################################################
# Check the OS version (windows and linux have release name checks)
@@ -811,23 +817,26 @@
######################################################
ifdef OPENJDK
-
-# The freetypecheck Makefile prints out "Failed" if not good enough
-$(TEMPDIR)/freetypeinfo: FRC
+ ifndef CROSS_COMPILE_ARCH
+ # The freetypecheck Makefile prints out "Failed" if not good enough
+ $(TEMPDIR)/freetypeinfo: FRC
@$(prep-target)
@(($(CD) $(BUILDDIR)/tools/freetypecheck && $(MAKE)) || \
$(ECHO) "Failed to build freetypecheck." ) > $@
-sane-freetype: $(TEMPDIR)/freetypeinfo
+ sane-freetype: $(TEMPDIR)/freetypeinfo
@if [ "`$(CAT) $< | $(GREP) Fail`" != "" ]; then \
$(ECHO) "ERROR: FreeType version " $(REQUIRED_FREETYPE_VERSION) \
" or higher is required. \n" \
"`$(CAT) $<` \n" >> $(ERROR_FILE) ; \
fi
-
+ else
+ #do nothing (cross-compiling)
+ sane-freetype:
+ endif
else
-#do nothing (not OpenJDK)
-sane-freetype:
+ #do nothing (not OpenJDK)
+ sane-freetype:
endif
######################################################
@@ -1306,7 +1315,7 @@
" Microsoft DirectX 9 SDK can be downloaded from the following location:\n" \
" http://msdn.microsoft.com/library/default.asp?url=/downloads/list/directx.asp\n" \
" Or http://www.microsoft.com/directx\n" \
- "" >> $(WARNING_FILE) ; \
+ "" >> $(WARNING_FILE) ; \
fi \
fi \
fi \
@@ -1337,13 +1346,16 @@
######################################################
# Check the compiler version(s)
######################################################
-CC_CHECK :=$(call CheckVersions,$(CC_VER),$(REQUIRED_CC_VER))
+ifdef REQUIRED_CC_VER
+ CC_CHECK :=$(call CheckVersions,$(CC_VER),$(REQUIRED_CC_VER))
+endif
sane-compiler: sane-link
+ifdef REQUIRED_CC_VER
@if [ "$(CC_CHECK)" = "missing" ]; then \
$(ECHO) "ERROR: The Compiler version is undefined. \n" \
"" >> $(ERROR_FILE) ; \
fi
-ifndef OPENJDK
+ ifndef OPENJDK
@if [ "$(CC_CHECK)" != "same" ]; then \
$(ECHO) "WARNING: The $(PLATFORM) compiler is not version $(REQUIRED_COMPILER_VERSION) $(REQUIRED_CC_VER) \n" \
" Specifically the $(REQUIRED_COMPILER_NAME) compiler. \n " \
@@ -1352,6 +1364,7 @@
" $(COMPILER_PATH) \n" \
"" >> $(WARNING_FILE) ; \
fi
+ endif
endif
######################################################
--- a/jdk/make/java/instrument/Makefile Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/java/instrument/Makefile Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -109,7 +109,7 @@
LDFLAGS += -R \$$ORIGIN/jli
endif
ifeq ($(PLATFORM), linux)
- LDFLAGS += -Wl,-z -Wl,origin
+ LDFLAGS += $(LDFLAG_Z_ORIGIN)
LDFLAGS += -Wl,--allow-shlib-undefined
LDFLAGS += -Wl,-rpath -Wl,\$$ORIGIN/jli
endif
--- a/jdk/make/java/jli/Makefile Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/java/jli/Makefile Mon Mar 21 16:57:18 2011 -0700
@@ -78,13 +78,17 @@
zutil.c
ifneq ($(PLATFORM), windows)
-
-FILES_c += \
- $(CTARGDIR)ergo.c \
- $(CTARGDIR)ergo_$(ERGO_FAMILY).c
+ FILES_c += ergo.c
+ ERGO_ARCH_FILE = ergo_$(ERGO_FAMILY).c
+ # if the architecture specific ergo file exists then
+ # use it, else use the generic definitions from ergo.c
+ ifneq ($(wildcard $(LAUNCHER_PLATFORM_SRC)/$(ERGO_ARCH_FILE)),)
+ FILES_c += $(ERGO_ARCH_FILE)
+ else
+ OTHER_CPPFLAGS += -DUSE_GENERIC_ERGO
+ endif
endif
-
# Names of arch directories
LIBARCH_DEFINES = -DLIBARCHNAME='"$(LIBARCH)"'
ifeq ($(PLATFORM), solaris)
--- a/jdk/make/java/jvm/Makefile Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/java/jvm/Makefile Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -43,7 +43,8 @@
$(PLATFORM_INCLUDE)/%.h: $(PLATFORM_SRC)/javavm/export/%.h
$(install-file)
-JVMCFG = $(LIBDIR)/$(LIBARCH)/jvm.cfg
+JVMCFG_DIR = $(LIBDIR)/$(LIBARCH)
+JVMCFG = $(JVMCFG_DIR)/jvm.cfg
#
# How to install jvm.cfg.
@@ -54,8 +55,21 @@
JVMCFG_ARCH = $(ARCH)
endif
+ifdef BUILD_CLIENT_ONLY
+$(JVMCFG)::
+ $(MKDIR) -p $(JVMCFG_DIR)
+ @# Update jvm.cfg to use -client by default and alias -server to -client
+ $(RM) -f $(JVMCFG)
+ $(ECHO) "-client KNOWN">$(JVMCFG)
+ $(ECHO) "-server ALIASED_TO -client">>$(JVMCFG)
+ $(ECHO) "-hotspot ALIASED_TO -client">>$(JVMCFG)
+ $(ECHO) "-classic WARN">>$(JVMCFG)
+ $(ECHO) "-native ERROR">>$(JVMCFG)
+ $(ECHO) "-green ERROR">>$(JVMCFG)
+else
$(JVMCFG): $(PLATFORM_SRC)/bin/$(JVMCFG_ARCH)/jvm.cfg
$(install-file)
+endif
all: build
--- a/jdk/make/java/nio/Makefile Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/java/nio/Makefile Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -820,7 +820,7 @@
$(GENSOR_EXE) : $(TEMPDIR)/$(GENSOR_SRC)
$(prep-target)
- ($(CD) $(TEMPDIR); $(CC) $(CPPFLAGS) $(LDDFLAGS) \
+ ($(CD) $(TEMPDIR); $(HOST_CC) $(CPPFLAGS) $(LDDFLAGS) \
-o genSocketOptionRegistry$(EXE_SUFFIX) $(GENSOR_SRC))
$(SCH_GEN)/SocketOptionRegistry.java: $(GENSOR_EXE)
@@ -851,7 +851,7 @@
$(GENUC_EXE) : $(GENUC_SRC)
$(prep-target)
- $(CC) $(CPPFLAGS) -o $@ $(GENUC_SRC)
+ $(HOST_CC) $(CPPFLAGS) -o $@ $(GENUC_SRC)
$(SFS_GEN)/UnixConstants.java: $(GENUC_EXE)
$(prep-target)
@@ -867,7 +867,7 @@
$(GENSC_EXE) : $(GENSC_SRC)
$(prep-target)
- $(CC) $(CPPFLAGS) -o $@ $(GENSC_SRC)
+ $(HOST_CC) $(CPPFLAGS) -o $@ $(GENSC_SRC)
$(SFS_GEN)/SolarisConstants.java: $(GENSC_EXE)
$(prep-target)
--- a/jdk/make/java/nio/mapfile-linux Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/java/nio/mapfile-linux Mon Mar 21 16:57:18 2011 -0700
@@ -95,6 +95,8 @@
Java_sun_nio_ch_NativeThread_current;
Java_sun_nio_ch_NativeThread_init;
Java_sun_nio_ch_NativeThread_signal;
+ Java_sun_nio_ch_Net_canIPv6SocketJoinIPv4Group0;
+ Java_sun_nio_ch_Net_canJoin6WithIPv4Group0;
Java_sun_nio_ch_Net_socket0;
Java_sun_nio_ch_Net_bind0;
Java_sun_nio_ch_Net_connect0;
--- a/jdk/make/java/nio/mapfile-solaris Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/java/nio/mapfile-solaris Mon Mar 21 16:57:18 2011 -0700
@@ -82,6 +82,8 @@
Java_sun_nio_ch_NativeThread_current;
Java_sun_nio_ch_NativeThread_init;
Java_sun_nio_ch_NativeThread_signal;
+ Java_sun_nio_ch_Net_canIPv6SocketJoinIPv4Group0;
+ Java_sun_nio_ch_Net_canJoin6WithIPv4Group0;
Java_sun_nio_ch_Net_socket0;
Java_sun_nio_ch_Net_bind0;
Java_sun_nio_ch_Net_connect0;
--- a/jdk/make/java/redist/Makefile Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/java/redist/Makefile Mon Mar 21 16:57:18 2011 -0700
@@ -76,8 +76,12 @@
INTERNAL_IMPORT_LIST = $(LIBDIR)/classlist
# List of files coming from outside this workspace
-IMPORT_LIST = $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVM_NAME) \
- $(LIB_LOCATION)/$(SERVER_LOCATION)/Xusage.txt
+ifndef BUILD_CLIENT_ONLY
+ IMPORT_LIST = $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVM_NAME) \
+ $(LIB_LOCATION)/$(SERVER_LOCATION)/Xusage.txt
+else
+ IMPORT_LIST =
+endif
# Hotspot client is only available on 32-bit non-Zero builds
ifneq ($(ZERO_BUILD), true)
@@ -97,10 +101,12 @@
$(call chmod-file, a+x)
# Get the hotspot .map and .pdb files for client and server
+ifndef BUILD_CLIENT_ONLY
IMPORT_LIST += \
$(LIBDIR)/$(JVMLIB_NAME) \
$(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMMAP_NAME) \
$(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMPDB_NAME)
+endif
# Add .map and .pdb files to the import path for client and kernel VMs.
# These are only available on 32-bit windows builds.
@@ -126,9 +132,11 @@
@$(prep-target)
-$(CP) $(HOTSPOT_KERNEL_PATH)/$(JVMMAP_NAME) $@
+ifndef BUILD_CLIENT_ONLY
$(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMMAP_NAME):
@$(prep-target)
-$(CP) $(HOTSPOT_SERVER_PATH)/$(JVMMAP_NAME) $@
+endif
$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMPDB_NAME):
@$(prep-target)
@@ -138,27 +146,32 @@
@$(prep-target)
-$(CP) $(HOTSPOT_KERNEL_PATH)/$(JVMPDB_NAME) $@
+ifndef BUILD_CLIENT_ONLY
$(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMPDB_NAME):
@$(prep-target)
-$(CP) $(HOTSPOT_SERVER_PATH)/$(JVMPDB_NAME) $@
+endif
# Windows ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Windows
else # PLATFORM
# NOT Windows vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv NOT Windows
-IMPORT_LIST += \
- $(LIB_LOCATION)/$(LIBJSIG_NAME) \
- $(LIB_LOCATION)/$(SERVER_LOCATION)/$(LIBJSIG_NAME)
+IMPORT_LIST += $(LIB_LOCATION)/$(LIBJSIG_NAME)
+ifndef BUILD_CLIENT_ONLY
+ IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/$(LIBJSIG_NAME)
+endif
ifeq ($(PLATFORM), solaris)
- IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDB_NAME)
-# The conditional can be removed when import JDKs contain these files.
-ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/$(JVMDTRACE_NAME)),)
- IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDTRACE_NAME)
-else
- $(warning WARNING: $(HOTSPOT_SERVER_PATH)/$(JVMDB_NAME) not found!)
-endif
-endif
+ ifndef BUILD_CLIENT_ONLY
+ IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDB_NAME)
+ # The conditional can be removed when import JDKs contain these files.
+ ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/$(JVMDTRACE_NAME)),)
+ IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDTRACE_NAME)
+ else
+ $(warning WARNING: $(HOTSPOT_SERVER_PATH)/$(JVMDB_NAME) not found!)
+ endif
+ endif
+endif
ifneq ($(ZERO_BUILD), true)
ifeq ($(ARCH_DATA_MODEL), 32)
@@ -179,18 +192,20 @@
$(warning WARNING: $(HOTSPOT_CLIENT_PATH)/$(JVMDTRACE_NAME) not found!)
endif
-# The conditional can be removed when import JDKs contain these files.
-ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/64/$(JVMDB_NAME)),)
- IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/64/$(JVMDB_NAME)
-else
- $(warning WARNING: $(HOTSPOT_SERVER_PATH)/64/$(JVMDB_NAME) not found!)
-endif
+ifndef BUILD_CLIENT_ONLY
+ # The conditional can be removed when import JDKs contain these files.
+ ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/64/$(JVMDB_NAME)),)
+ IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/64/$(JVMDB_NAME)
+ else
+ $(warning WARNING: $(HOTSPOT_SERVER_PATH)/64/$(JVMDB_NAME) not found!)
+ endif
-# The conditional can be removed when import JDKs contain these files.
-ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/64/$(JVMDTRACE_NAME)),)
- IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/64/$(JVMDTRACE_NAME)
-else
- $(warning WARNING: $(HOTSPOT_SERVER_PATH)/64/$(JVMDTRACE_NAME) not found!)
+ # The conditional can be removed when import JDKs contain these files.
+ ifneq ($(wildcard $(HOTSPOT_SERVER_PATH)/64/$(JVMDTRACE_NAME)),)
+ IMPORT_LIST += $(LIB_LOCATION)/$(SERVER_LOCATION)/64/$(JVMDTRACE_NAME)
+ else
+ $(warning WARNING: $(HOTSPOT_SERVER_PATH)/64/$(JVMDTRACE_NAME) not found!)
+ endif
endif
# For backwards compatability, make a link of the 32-bit client JVM to $(LIBDIR)
@@ -222,10 +237,16 @@
$(install-import-file)
@$(call binary_file_verification,$@)
+ifndef BUILD_CLIENT_ONLY
$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(LIBJSIG_NAME) \
$(LIB_LOCATION)/$(SERVER_LOCATION)/$(LIBJSIG_NAME):
@$(prep-target)
$(call install-sym-link, ../$(LIBJSIG_NAME))
+else
+$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(LIBJSIG_NAME):
+ @$(prep-target)
+ $(call install-sym-link, ../$(LIBJSIG_NAME))
+endif
$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMDB_NAME): $(HOTSPOT_CLIENT_PATH)/$(JVMDB_NAME)
$(install-import-file)
@@ -235,6 +256,7 @@
$(install-import-file)
@$(call binary_file_verification,$@)
+ifndef BUILD_CLIENT_ONLY
$(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDB_NAME): $(HOTSPOT_SERVER_PATH)/$(JVMDB_NAME)
$(install-import-file)
@$(call binary_file_verification,$@)
@@ -242,6 +264,7 @@
$(LIB_LOCATION)/$(SERVER_LOCATION)/64/$(JVMDB_NAME): $(HOTSPOT_SERVER_PATH)/64/$(JVMDB_NAME)
$(install-import-file)
@$(call binary_file_verification,$@)
+endif
$(LIB_LOCATION)/$(CLIENT_LOCATION)/$(JVMDTRACE_NAME): $(HOTSPOT_CLIENT_PATH)/$(JVMDTRACE_NAME)
$(install-import-file)
@@ -251,6 +274,7 @@
$(install-import-file)
@$(call binary_file_verification,$@)
+ifndef BUILD_CLIENT_ONLY
$(LIB_LOCATION)/$(SERVER_LOCATION)/$(JVMDTRACE_NAME): $(HOTSPOT_SERVER_PATH)/$(JVMDTRACE_NAME)
$(install-import-file)
@$(call binary_file_verification,$@)
@@ -265,6 +289,7 @@
$(LIB_LOCATION)/$(SERVER_LOCATION)/Xusage.txt : $(HOTSPOT_SERVER_PATH)/Xusage.txt
$(install-import-file)
+endif
$(LIB_LOCATION)/$(CLIENT_LOCATION)/Xusage.txt : $(HOTSPOT_CLIENT_PATH)/Xusage.txt
$(install-import-file)
--- a/jdk/make/javax/sound/SoundDefs.gmk Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/javax/sound/SoundDefs.gmk Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2002, 2007, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -73,6 +73,15 @@
ifeq ($(ARCH), amd64)
CPPFLAGS += -DX_ARCH=X_AMD64
endif # ARCH amd64
+
+ ifeq ($(ARCH), arm)
+ CPPFLAGS += -DX_ARCH=X_ARM
+ endif # ARCH arm
+
+ ifeq ($(ARCH), ppc)
+ CPPFLAGS += -DX_ARCH=X_PPC
+ endif # ARCH ppc
+
endif
--- a/jdk/make/sun/jdbc/Makefile Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/sun/jdbc/Makefile Mon Mar 21 16:57:18 2011 -0700
@@ -61,7 +61,7 @@
# ODBC_LIBRARY_LOCATION, and delete the variable assignments below.
#
# Tell linker to ignore missing externals when building this shared library.
- LDFLAGS_DEFS_OPTION = -z nodefs
+ LDFLAGS_DEFS_OPTION = -Xlinker -z -Xlinker nodefs
# Define a place to create the fake libraries and their names.
ODBC_LIBRARY_LOCATION = $(TEMPDIR)
ODBC_FAKE_LIBRARIES = $(ODBC_LIBRARY_LOCATION)/libodbcinst.so $(ODBC_LIBRARY_LOCATION)/libodbc.so
--- a/jdk/make/sun/nio/cs/FILES_java.gmk Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/sun/nio/cs/FILES_java.gmk Mon Mar 21 16:57:18 2011 -0700
@@ -376,6 +376,7 @@
sun/nio/cs/ext/HKSCSMapping.java \
sun/nio/cs/ext/HKSCS2001Mapping.java \
sun/nio/cs/ext/HKSCS_XPMapping.java \
+ sun/nio/cs/ext/IBM1364.java \
sun/nio/cs/ext/IBM1381.java \
sun/nio/cs/ext/IBM1383.java \
sun/nio/cs/ext/IBM930.java \
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/make/tools/CharsetMapping/IBM1364.c2b Mon Mar 21 16:57:18 2011 -0700
@@ -0,0 +1,22 @@
+#
+# Diff of
+# b2c: cdctables.zip/Package2.zip/IBM-1364A.zip/055444B0.TPMAP110
+# c2b: cdctables.zip/Package2.zip/IBM-1364A.zip/055444B0.UPMAP110
+# shows there are 6 additional c->b entries in UPMAP110, they are
+# listed below (in b->c form)
+#
+# UPMAP110 also defines
+# <subchar> \xFE\xFE
+# and commend out
+# #<subchar1> \x3F
+# with
+#
+# <UFFFD> \xFE\xFD # (SUB)
+# <UFFFD> \xFE\xFE # (SUB)
+#
+4148 00AD
+4143 00B7
+4149 2015
+42A1 223C
+496F 2299
+4954 FF5E
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/make/tools/CharsetMapping/IBM1364.map Mon Mar 21 16:57:18 2011 -0700
@@ -0,0 +1,19774 @@
+#
+# b2c mapping for IBM1364, generated from
+# cdctables.zip/Package2.zip/IBM-1364A.zip/055444B0.TPMAP110
+# which is an updated version of IBM-1364 (with EURO)
+#
+# Replacement suggestion from the CDC table are
+# U+001A for SBCS
+# U+FFFD for DBCS
+00 0000
+01 0001
+02 0002
+03 0003
+04 009C
+05 0009
+06 0086
+07 007F
+08 0097
+09 008D
+0A 008E
+0B 000B
+0C 000C
+0D 000D
+10 0010
+11 0011
+12 0012
+13 0013
+14 009D
+15 0085
+16 0008
+17 0087
+18 0018
+19 0019
+1A 0092
+1B 008F
+1C 001C
+1D 001D
+1E 001E
+1F 001F
+20 0080
+21 0081
+22 0082
+23 0083
+24 0084
+25 000A
+26 0017
+27 001B
+28 0088
+29 0089
+2A 008A
+2B 008B
+2C 008C
+2D 0005
+2E 0006
+2F 0007
+30 0090
+31 0091
+32 0016
+33 0093
+34 0094
+35 0095
+36 0096
+37 0004
+38 0098
+39 0099
+3A 009A
+3B 009B
+3C 0014
+3D 0015
+3E 009E
+3F 001A
+40 0020
+42 FFA0
+43 FFA1
+44 FFA2
+45 FFA3
+46 FFA4
+47 FFA5
+48 FFA6
+49 FFA7
+4A 00A2
+4B 002E
+4C 003C
+4D 0028
+4E 002B
+4F 007C
+50 0026
+52 FFA8
+53 FFA9
+54 FFAA
+55 FFAB
+56 FFAC
+57 FFAD
+58 FFAE
+59 FFAF
+5A 0021
+5B 0024
+5C 002A
+5D 0029
+5E 003B
+5F 00AC
+60 002D
+61 002F
+62 FFB0
+63 FFB1
+64 FFB2
+65 FFB3
+66 FFB4
+67 FFB5
+68 FFB6
+69 FFB7
+6A 00A6
+6B 002C
+6C 0025
+6D 005F
+6E 003E
+6F 003F
+70 005B
+72 FFB8
+73 FFB9
+74 FFBA
+75 FFBB
+76 FFBC
+77 FFBD
+78 FFBE
+79 0060
+7A 003A
+7B 0023
+7C 0040
+7D 0027
+7E 003D
+7F 0022
+80 005D
+81 0061
+82 0062
+83 0063
+84 0064
+85 0065
+86 0066
+87 0067
+88 0068
+89 0069
+8A FFC2
+8B FFC3
+8C FFC4
+8D FFC5
+8E FFC6
+8F FFC7
+91 006A
+92 006B
+93 006C
+94 006D
+95 006E
+96 006F
+97 0070
+98 0071
+99 0072
+9A FFCA
+9B FFCB
+9C FFCC
+9D FFCD
+9E FFCE
+9F FFCF
+A0 203E
+A1 007E
+A2 0073
+A3 0074
+A4 0075
+A5 0076
+A6 0077
+A7 0078
+A8 0079
+A9 007A
+AA FFD2
+AB FFD3
+AC FFD4
+AD FFD5
+AE FFD6
+AF FFD7
+B0 005E
+B2 005C
+BA FFDA
+BB FFDB
+BC FFDC
+C0 007B
+C1 0041
+C2 0042
+C3 0043
+C4 0044
+C5 0045
+C6 0046
+C7 0047
+C8 0048
+C9 0049
+D0 007D
+D1 004A
+D2 004B
+D3 004C
+D4 004D
+D5 004E
+D6 004F
+D7 0050
+D8 0051
+D9 0052
+E0 20A9
+E2 0053
+E3 0054
+E4 0055
+E5 0056
+E6 0057
+E7 0058
+E8 0059
+E9 005A
+F0 0030
+F1 0031
+F2 0032
+F3 0033
+F4 0034
+F5 0035
+F6 0036
+F7 0037
+F8 0038
+F9 0039
+FF 009F
+4040 3000
+4141 3001
+4142 3002
+4143 30FB
+4144 2025
+4145 2026
+4146 00A8
+4147 3003
+4148 2010
+4149 2014
+414A 2225
+414B FF3C
+414C FFE3
+414D 2018
+414E 2019
+414F 201C
+4150 201D
+4151 3014
+4152 3015
+4153 3008
+4154 3009
+4155 300A
+4156 300B
+4157 300C
+4158 300D
+4159 300E
+415A 300F
+415B 3010
+415C 3011
+415D 00B1
+415E 00D7
+415F 00F7
+4160 01C2
+4161 2266
+4162 2267
+4163 221E
+4164 2234
+4165 00B0
+4166 2032
+4167 2033
+4168 2103
+4169 212A
+416A FF3E
+416B FFE1
+416C FFE5
+416D 3396
+416E 3397
+416F 2113
+4170 33C4
+4171 339C
+4172 339D
+4173 339E
+4174 338E
+4175 338F
+4176 00A7
+4177 203B
+4178 2606
+4179 2605
+417A 25CB
+417B 25CF
+417C 25CE
+417D 25C7
+417E 25C6
+417F 25A1
+4180 25A0
+4181 25B3
+4182 25B2
+4183 25BD
+4184 25BC
+4185 2192
+4186 2190
+4187 2191
+4188 2193
+4189 2194
+418A 3013
+418B FF3B
+418C FF3D
+418D 2260
+418E 2264
+418F 2265
+4190 212B
+4191 2642
+4192 2640
+4193 2220
+4194 22A5
+4195 2312
+4196 2202
+4197 2207
+4198 2261
+4199 2252
+419A 226A
+419B 226B
+419C 221A
+419D 223D
+424A FFE0
+424B FF0E
+424C FF1C
+424D FF08
+424E FF0B
+424F FF5C
+4250 FF06
+425A FF01
+425B FF04
+425C FF0A
+425D FF09
+425E FF1B
+425F FFE2
+4260 FF0D
+4261 FF0F
+426A FFE4
+426B FF0C
+426C FF05
+426D FF3F
+426E FF1E
+426F FF1F
+4279 FF40
+427A FF1A
+427B FF03
+427C FF20
+427D FF07
+427E FF1D
+427F FF02
+4281 FF41
+4282 FF42
+4283 FF43
+4284 FF44
+4285 FF45
+4286 FF46
+4287 FF47
+4288 FF48
+4289 FF49
+4291 FF4A
+4292 FF4B
+4293 FF4C
+4294 FF4D
+4295 FF4E
+4296 FF4F
+4297 FF50
+4298 FF51
+4299 FF52
+42A1 301C
+42A2 FF53
+42A3 FF54
+42A4 FF55
+42A5 FF56
+42A6 FF57
+42A7 FF58
+42A8 FF59
+42A9 FF5A
+42C0 FF5B
+42C1 FF21
+42C2 FF22
+42C3 FF23
+42C4 FF24
+42C5 FF25
+42C6 FF26
+42C7 FF27
+42C8 FF28
+42C9 FF29
+42D0 FF5D
+42D1 FF2A
+42D2 FF2B
+42D3 FF2C
+42D4 FF2D
+42D5 FF2E
+42D6 FF2F
+42D7 FF30
+42D8 FF31
+42D9 FF32
+42E0 FFE6
+42E2 FF33
+42E3 FF34
+42E4 FF35
+42E5 FF36
+42E6 FF37
+42E7 FF38
+42E8 FF39
+42E9 FF3A
+42F0 FF10
+42F1 FF11
+42F2 FF12
+42F3 FF13
+42F4 FF14
+42F5 FF15
+42F6 FF16
+42F7 FF17
+42F8 FF18
+42F9 FF19
+4341 3165
+4342 3166
+4343 3167
+4344 3168
+4345 3169
+4346 316A
+4347 316B
+4348 316C
+4349 316D
+434A 316E
+434B 316F
+434C 3170
+434D 3171
+434E 3172
+434F 3173
+4350 3174
+4351 3175
+4352 3176
+4353 3177
+4354 3178
+4355 3179
+4356 317A
+4357 317B
+4358 317C
+4359 317D
+435A 317E
+435B 317F
+435C 3180
+435D 3181
+435E 3182
+435F 3183
+4360 3184
+4361 3185
+4362 3186
+4363 3187
+4364 3188
+4365 3189
+4366 318A
+4367 318B
+4368 318C
+4369 318D
+436A 318E
+4441 3041
+4442 3042
+4443 3043
+4444 3044
+4445 3045
+4446 3046
+4447 3047
+4448 3048
+4449 3049
+444A 304A
+444B 304B
+444C 304C
+444D 304D
+444E 304E
+444F 304F
+4450 3050
+4451 3051
+4452 3052
+4453 3053
+4454 3054
+4455 3055
+4456 3056
+4457 3057
+4458 3058
+4459 3059
+445A 305A
+445B 305B
+445C 305C
+445D 305D
+445E 305E
+445F 305F
+4460 3060
+4461 3061
+4462 3062
+4463 3063
+4464 3064
+4465 3065
+4466 3066
+4467 3067
+4468 3068
+4469 3069
+446A 306A
+446B 306B
+446C 306C
+446D 306D
+446E 306E
+446F 306F
+4470 3070
+4471 3071
+4472 3072
+4473 3073
+4474 3074
+4475 3075
+4476 3076
+4477 3077
+4478 3078
+4479 3079
+447A 307A
+447B 307B
+447C 307C
+447D 307D
+447E 307E
+447F 307F
+4480 3080
+4481 3081
+4482 3082
+4483 3083
+4484 3084
+4485 3085
+4486 3086
+4487 3087
+4488 3088
+4489 3089
+448A 308A
+448B 308B
+448C 308C
+448D 308D
+448E 308E
+448F 308F
+4490 3090
+4491 3091
+4492 3092
+4493 3093
+4541 30A1
+4542 30A2
+4543 30A3
+4544 30A4
+4545 30A5
+4546 30A6
+4547 30A7
+4548 30A8
+4549 30A9
+454A 30AA
+454B 30AB
+454C 30AC
+454D 30AD
+454E 30AE
+454F 30AF
+4550 30B0
+4551 30B1
+4552 30B2
+4553 30B3
+4554 30B4
+4555 30B5
+4556 30B6
+4557 30B7
+4558 30B8
+4559 30B9
+455A 30BA
+455B 30BB
+455C 30BC
+455D 30BD
+455E 30BE
+455F 30BF
+4560 30C0
+4561 30C1
+4562 30C2
+4563 30C3
+4564 30C4
+4565 30C5
+4566 30C6
+4567 30C7
+4568 30C8
+4569 30C9
+456A 30CA
+456B 30CB
+456C 30CC
+456D 30CD
+456E 30CE
+456F 30CF
+4570 30D0
+4571 30D1
+4572 30D2
+4573 30D3
+4574 30D4
+4575 30D5
+4576 30D6
+4577 30D7
+4578 30D8
+4579 30D9
+457A 30DA
+457B 30DB
+457C 30DC
+457D 30DD
+457E 30DE
+457F 30DF
+4580 30E0
+4581 30E1
+4582 30E2
+4583 30E3
+4584 30E4
+4585 30E5
+4586 30E6
+4587 30E7
+4588 30E8
+4589 30E9
+458A 30EA
+458B 30EB
+458C 30EC
+458D 30ED
+458E 30EE
+458F 30EF
+4590 30F0
+4591 30F1
+4592 30F2
+4593 30F3
+4594 30F4
+4595 30F5
+4596 30F6
+4641 2170
+4642 2171
+4643 2172
+4644 2173
+4645 2174
+4646 2175
+4647 2176
+4648 2177
+4649 2178
+464A 2179
+4650 2160
+4651 2161
+4652 2162
+4653 2163
+4654 2164
+4655 2165
+4656 2166
+4657 2167
+4658 2168
+4659 2169
+4661 0391
+4662 0392
+4663 0393
+4664 0394
+4665 0395
+4666 0396
+4667 0397
+4668 0398
+4669 0399
+466A 039A
+466B 039B
+466C 039C
+466D 039D
+466E 039E
+466F 039F
+4670 03A0
+4671 03A1
+4672 03A3
+4673 03A4
+4674 03A5
+4675 03A6
+4676 03A7
+4677 03A8
+4678 03A9
+4681 03B1
+4682 03B2
+4683 03B3
+4684 03B4
+4685 03B5
+4686 03B6
+4687 03B7
+4688 03B8
+4689 03B9
+468A 03BA
+468B 03BB
+468C 03BC
+468D 03BD
+468E 03BE
+468F 03BF
+4690 03C0
+4691 03C1
+4692 03C3
+4693 03C4
+4694 03C5
+4695 03C6
+4696 03C7
+4697 03C8
+4698 03C9
+4741 2500
+4742 2502
+4743 250C
+4744 2510
+4745 2518
+4746 2514
+4747 251C
+4748 252C
+4749 2524
+474A 2534
+474B 253C
+474C 2501
+474D 2503
+474E 250F
+474F 2513
+4750 251B
+4751 2517
+4752 2523
+4753 2533
+4754 252B
+4755 253B
+4756 254B
+4757 2520
+4758 252F
+4759 2528
+475A 2537
+475B 253F
+475C 251D
+475D 2530
+475E 2525
+475F 2538
+4760 2542
+4761 2512
+4762 2511
+4763 251A
+4764 2519
+4765 2516
+4766 2515
+4767 250E
+4768 250D
+4769 251E
+476A 251F
+476B 2521
+476C 2522
+476D 2526
+476E 2527
+476F 2529
+4770 252A
+4771 252D
+4772 252E
+4773 2531
+4774 2532
+4775 2535
+4776 2536
+4777 2539
+4778 253A
+4779 253D
+477A 253E
+477B 2540
+477C 2541
+477D 2543
+477E 2544
+477F 2545
+4780 2546
+4781 2547
+4782 2548
+4783 2549
+4784 254A
+4841 3395
+4842 3398
+4843 33A3
+4844 33A4
+4845 33A5
+4846 33A6
+4847 3399
+4848 339A
+4849 339B
+484A 339F
+484B 33A0
+484C 33A1
+484D 33A2
+484E 33CA
+484F 338D
+4850 33CF
+4851 3388
+4852 3389
+4853 33C8
+4854 33A7
+4855 33A8
+4856 33B0
+4857 33B1
+4858 33B2
+4859 33B3
+485A 33B4
+485B 33B5
+485C 33B6
+485D 33B7
+485E 33B8
+485F 33B9
+4860 3380
+4861 3381
+4862 3382
+4863 3383
+4864 3384
+4865 33BA
+4866 33BB
+4867 33BC
+4868 33BD
+4869 33BE
+486A 33BF
+486B 3390
+486C 3391
+486D 3392
+486E 3393
+486F 3394
+4870 2126
+4871 33C0
+4872 33C1
+4873 338A
+4874 338B
+4875 338C
+4876 33D6
+4877 33C5
+4878 33AD
+4879 33AE
+487A 33AF
+487B 33DB
+487C 33A9
+487D 33AA
+487E 33AB
+487F 33AC
+4880 33DD
+4881 33D0
+4882 33D3
+4883 33C3
+4884 33C9
+4885 33DC
+4886 33C6
+4941 221D
+4942 2235
+4943 222B
+4944 222C
+4945 2208
+4946 220B
+4947 2286
+4948 2287
+4949 2282
+494A 2283
+494B 222A
+494C 2229
+494D 2227
+494E 2228
+494F 21D2
+4950 21D4
+4951 2200
+4952 2203
+4953 00B4
+4954 02DC
+4955 02C7
+4956 02D8
+4957 02DD
+4958 02DA
+4959 02D9
+495A 00B8
+495B 02DB
+495C 00A1
+495D 00BF
+495E 02D0
+495F 222E
+4960 2211
+4961 220F
+4962 00A4
+4963 2109
+4964 2030
+4965 25C1
+4966 25C0
+4967 25B7
+4968 25B6
+4969 2664
+496A 2660
+496B 2661
+496C 2665
+496D 2667
+496E 2663
+496F 25C9
+4970 25C8
+4971 25A3
+4972 25D0
+4973 25D1
+4974 2592
+4975 25A4
+4976 25A5
+4977 25A8
+4978 25A7
+4979 25A6
+497A 25A9
+497B 2668
+497C 260F
+497D 260E
+497E 261C
+497F 261E
+4980 00B6
+4981 2020
+4982 2021
+4983 2195
+4984 2197
+4985 2199
+4986 2196
+4987 2198
+4988 266D
+4989 2669
+498A 266A
+498B 266C
+498C 327F
+498D 321C
+498E 2116
+498F 33C7
+4990 2122
+4991 33C2
+4992 33D8
+4993 2121
+4994 02BA
+4995 20AC
+4996 00AE
+4A41 0410
+4A42 0411
+4A43 0412
+4A44 0413
+4A45 0414
+4A46 0415
+4A47 0401
+4A48 0416
+4A49 0417
+4A4A 0418
+4A4B 0419
+4A4C 041A
+4A4D 041B
+4A4E 041C
+4A4F 041D
+4A50 041E
+4A51 041F
+4A52 0420
+4A53 0421
+4A54 0422
+4A55 0423
+4A56 0424
+4A57 0425
+4A58 0426
+4A59 0427
+4A5A 0428
+4A5B 0429
+4A5C 042A
+4A5D 042B
+4A5E 042C
+4A5F 042D
+4A60 042E
+4A61 042F
+4A62 0430
+4A63 0431
+4A64 0432
+4A65 0433
+4A66 0434
+4A67 0435
+4A68 0451
+4A69 0436
+4A6A 0437
+4A6B 0438
+4A6C 0439
+4A6D 043A
+4A6E 043B
+4A6F 043C
+4A70 043D
+4A71 043E
+4A72 043F
+4A73 0440
+4A74 0441
+4A75 0442
+4A76 0443
+4A77 0444
+4A78 0445
+4A79 0446
+4A7A 0447
+4A7B 0448
+4A7C 0449
+4A7D 044A
+4A7E 044B
+4A7F 044C
+4A80 044D
+4A81 044E
+4A82 044F
+4B41 00C6
+4B42 00D0
+4B43 00AA
+4B44 0126
+4B46 0132
+4B48 013F
+4B49 0141
+4B4A 00D8
+4B4B 0152
+4B4C 00BA
+4B4D 00DE
+4B4E 0166
+4B4F 014A
+4B51 3260
+4B52 3261
+4B53 3262
+4B54 3263
+4B55 3264
+4B56 3265
+4B57 3266
+4B58 3267
+4B59 3268
+4B5A 3269
+4B5B 326A
+4B5C 326B
+4B5D 326C
+4B5E 326D
+4B5F 326E
+4B60 326F
+4B61 3270
+4B62 3271
+4B63 3272
+4B64 3273
+4B65 3274
+4B66 3275
+4B67 3276
+4B68 3277
+4B69 3278
+4B6A 3279
+4B6B 327A
+4B6C 327B
+4B6D 24D0
+4B6E 24D1
+4B6F 24D2
+4B70 24D3
+4B71 24D4
+4B72 24D5
+4B73 24D6
+4B74 24D7
+4B75 24D8
+4B76 24D9
+4B77 24DA
+4B78 24DB
+4B79 24DC
+4B7A 24DD
+4B7B 24DE
+4B7C 24DF
+4B7D 24E0
+4B7E 24E1
+4B7F 24E2
+4B80 24E3
+4B81 24E4
+4B82 24E5
+4B83 24E6
+4B84 24E7
+4B85 24E8
+4B86 24E9
+4B87 2460
+4B88 2461
+4B89 2462
+4B8A 2463
+4B8B 2464
+4B8C 2465
+4B8D 2466
+4B8E 2467
+4B8F 2468
+4B90 2469
+4B91 246A
+4B92 246B
+4B93 246C
+4B94 246D
+4B95 246E
+4B96 00BD
+4B97 2153
+4B98 2154
+4B99 00BC
+4B9A 00BE
+4B9B 215B
+4B9C 215C
+4B9D 215D
+4B9E 215E
+4BA0 00E6
+4BA1 0111
+4BA2 00F0
+4BA3 0127
+4BA4 0131
+4BA5 0133
+4BA6 0138
+4BA7 0140
+4BA8 0142
+4BA9 00F8
+4BAA 0153
+4BAB 00DF
+4BAC 00FE
+4BAD 0167
+4BAE 014B
+4BAF 0149
+4BB0 3200
+4BB1 3201
+4BB2 3202
+4BB3 3203
+4BB4 3204
+4BB5 3205
+4BB6 3206
+4BB7 3207
+4BB8 3208
+4BB9 3209
+4BBA 320A
+4BBB 320B
+4BBC 320C
+4BBD 320D
+4BBE 320E
+4BBF 320F
+4BC0 3210
+4BC1 3211
+4BC2 3212
+4BC3 3213
+4BC4 3214
+4BC5 3215
+4BC6 3216
+4BC7 3217
+4BC8 3218
+4BC9 3219
+4BCA 321A
+4BCB 321B
+4BCC 249C
+4BCD 249D
+4BCE 249E
+4BCF 249F
+4BD0 24A0
+4BD1 24A1
+4BD2 24A2
+4BD3 24A3
+4BD4 24A4
+4BD5 24A5
+4BD6 24A6
+4BD7 24A7
+4BD8 24A8
+4BD9 24A9
+4BDA 24AA
+4BDB 24AB
+4BDC 24AC
+4BDD 24AD
+4BDE 24AE
+4BDF 24AF
+4BE0 24B0
+4BE1 24B1
+4BE2 24B2
+4BE3 24B3
+4BE4 24B4
+4BE5 24B5
+4BE6 2474
+4BE7 2475
+4BE8 2476
+4BE9 2477
+4BEA 2478
+4BEB 2479
+4BEC 247A
+4BED 247B
+4BEE 247C
+4BEF 247D
+4BF0 247E
+4BF1 247F
+4BF2 2480
+4BF3 2481
+4BF4 2482
+4BF5 00B9
+4BF6 00B2
+4BF7 00B3
+4BF8 2074
+4BF9 207F
+4BFA 2081
+4BFB 2082
+4BFC 2083
+4BFD 2084
+4C41 1100
+4C42 1101
+4C43 1102
+4C44 1103
+4C45 1104
+4C46 1105
+4C47 1106
+4C48 1107
+4C49 1108
+4C4A 1109
+4C4B 110A
+4C4C 110B
+4C4D 110C
+4C4E 110D
+4C4F 110E
+4C50 110F
+4C51 1110
+4C52 1111
+4C53 1112
+4C54 1113
+4C55 1114
+4C56 1115
+4C57 1116
+4C58 1117
+4C59 1118
+4C5A 1119
+4C5B 111A
+4C5C 111B
+4C5D 111C
+4C5E 111D
+4C5F 111E
+4C60 111F
+4C61 1120
+4C62 1121
+4C63 1122
+4C64 1123
+4C65 1124
+4C66 1125
+4C67 1126
+4C68 1127
+4C69 1128
+4C6A 1129
+4C6B 112A
+4C6C 112B
+4C6D 112C
+4C6E 112D
+4C6F 112E
+4C70 112F
+4C71 1130
+4C72 1131
+4C73 1132
+4C74 1133
+4C75 1134
+4C76 1135
+4C77 1136
+4C78 1137
+4C79 1138
+4C7A 1139
+4C7B 113A
+4C7C 113B
+4C7D 113C
+4C7E 113D
+4C7F 113E
+4C80 113F
+4C81 1140
+4C82 1141
+4C83 1142
+4C84 1143
+4C85 1144
+4C86 1145
+4C87 1146
+4C88 1147
+4C89 1148
+4C8A 1149
+4C8B 114A
+4C8C 114B
+4C8D 114C
+4C8E 114D
+4C8F 114E
+4C90 114F
+4C91 1150
+4C92 1151
+4C93 1152
+4C94 1153
+4C95 1154
+4C96 1155
+4C97 1156
+4C98 1157
+4C99 1158
+4C9A 1159
+4D41 115F
+4D42 1160
+4D43 1161
+4D44 1162
+4D45 1163
+4D46 1164
+4D47 1165
+4D48 1166
+4D49 1167
+4D4A 1168
+4D4B 1169
+4D4C 116A
+4D4D 116B
+4D4E 116C
+4D4F 116D
+4D50 116E
+4D51 116F
+4D52 1170
+4D53 1171
+4D54 1172
+4D55 1173
+4D56 1174
+4D57 1175
+4D58 1176
+4D59 1177
+4D5A 1178
+4D5B 1179
+4D5C 117A
+4D5D 117B
+4D5E 117C
+4D5F 117D
+4D60 117E
+4D61 117F
+4D62 1180
+4D63 1181
+4D64 1182
+4D65 1183
+4D66 1184
+4D67 1185
+4D68 1186
+4D69 1187
+4D6A 1188
+4D6B 1189
+4D6C 118A
+4D6D 118B
+4D6E 118C
+4D6F 118D
+4D70 118E
+4D71 118F
+4D72 1190
+4D73 1191
+4D74 1192
+4D75 1193
+4D76 1194
+4D77 1195
+4D78 1196
+4D79 1197
+4D7A 1198
+4D7B 1199
+4D7C 119A
+4D7D 119B
+4D7E 119C
+4D7F 119D
+4D80 119E
+4D81 119F
+4D82 11A0
+4D83 11A1
+4D84 11A2
+4E41 11A8
+4E42 11A9
+4E43 11AA
+4E44 11AB
+4E45 11AC
+4E46 11AD
+4E47 11AE
+4E48 11AF
+4E49 11B0
+4E4A 11B1
+4E4B 11B2
+4E4C 11B3
+4E4D 11B4
+4E4E 11B5
+4E4F 11B6
+4E50 11B7
+4E51 11B8
+4E52 11B9
+4E53 11BA
+4E54 11BB
+4E55 11BC
+4E56 11BD
+4E57 11BE
+4E58 11BF
+4E59 11C0
+4E5A 11C1
+4E5B 11C2
+4E5C 11C3
+4E5D 11C4
+4E5E 11C5
+4E5F 11C6
+4E60 11C7
+4E61 11C8
+4E62 11C9
+4E63 11CA
+4E64 11CB
+4E65 11CC
+4E66 11CD
+4E67 11CE
+4E68 11CF
+4E69 11D0
+4E6A 11D1
+4E6B 11D2
+4E6C 11D3
+4E6D 11D4
+4E6E 11D5
+4E6F 11D6
+4E70 11D7
+4E71 11D8
+4E72 11D9
+4E73 11DA
+4E74 11DB
+4E75 11DC
+4E76 11DD
+4E77 11DE
+4E78 11DF
+4E79 11E0
+4E7A 11E1
+4E7B 11E2
+4E7C 11E3
+4E7D 11E4
+4E7E 11E5
+4E7F 11E6
+4E80 11E7
+4E81 11E8
+4E82 11E9
+4E83 11EA
+4E84 11EB
+4E85 11EC
+4E86 11ED
+4E87 11EE
+4E88 11EF
+4E89 11F0
+4E8A 11F1
+4E8B 11F2
+4E8C 11F3
+4E8D 11F4
+4E8E 11F5
+4E8F 11F6
+4E90 11F7
+4E91 11F8
+4E92 11F9
+5041 4F3D
+5042 4F73
+5043 5047
+5044 50F9
+5045 52A0
+5046 53EF
+5047 5475
+5048 54E5
+5049 5609
+504A 5AC1
+504B 5BB6
+504C 6687
+504D 67EF
+504E 67B6
+504F 6B4C
+5050 7A3C
+5051 82DB
+5052 8304
+5053 8857
+5054 8888
+5055 8A36
+5056 8CC8
+5057 8DCF
+5058 8EFB
+5059 8FE6
+505A 99D5
+505B 523B
+505C 5374
+505D 5404
+505E F843
+505F 606A
+5060 64F1
+5061 6BBC
+5062 73CF
+5063 811A
+5064 89BA
+5065 89D2
+5066 95A3
+5067 520A
+5068 58BE
+5069 5978
+506A 59E6
+506B 5E72
+506C 5E79
+506D 61C7
+506E 63C0
+506F 6746
+5070 6F97
+5071 764E
+5072 770B
+5073 7A08
+5074 7AFF
+5075 7C21
+5076 826E
+5077 8271
+5078 809D
+5079 8AEB
+507A 9593
+507B 4E6B
+507C 559D
+507D 66F7
+507E 6E34
+507F 78A3
+5080 7AED
+5081 8910
+5082 7FAF
+5083 845B
+5084 97A8
+5085 52D8
+5086 574E
+5087 582A
+5088 5D4C
+5089 611F
+508A 61BE
+508B 6562
+508C 67D1
+508D 6A44
+508E 6E1B
+508F 7518
+5090 75B3
+5091 76E3
+5092 7D3A
+5093 9163
+5094 9451
+5095 9F95
+5096 5323
+5097 5CAC
+5098 7532
+5099 80DB
+509A 9240
+509B 9598
+509C 5CA1
+509D 525B
+509E 59DC
+509F 5D17
+50A0 5EB7
+50A1 5F3A
+50A2 5F4A
+50A3 6177
+50A4 6C5F
+50A5 7586
+50A6 7DB1
+50A7 8941
+50A8 7CE0
+50A9 8154
+50AA 8591
+50AB 8B1B
+50AC 92FC
+50AD 964D
+50AE 4ECB
+50AF 4EF7
+50B0 500B
+50B1 51F1
+50B2 6137
+50B3 613E
+50B4 6168
+50B5 6539
+50B6 69EA
+50B7 6F11
+50B8 75A5
+50B9 7686
+50BA 76D6
+50BB 7B87
+50BC 82A5
+50BD 84CB
+50BE 958B
+50BF 5BA2
+50C0 5751
+50C1 F901
+50C2 7CB3
+50C3 7FB9
+50C4 91B5
+50C5 53BB
+50C6 5C45
+50C7 5DE8
+50C8 62D2
+50C9 636E
+50CA 64DA
+50CB 6E20
+50CC 70AC
+50CD 64E7
+50CE 8DDD
+50CF 907D
+50D0 F902
+50D1 F844
+50D2 92F8
+50D3 4E7E
+50D4 4EF6
+50D5 5065
+50D6 5DFE
+50D7 5EFA
+50D8 6106
+50D9 8654
+50DA 8E47
+50DB 9375
+50DC 9A2B
+50DD 4E5E
+50DE 5091
+50DF 6770
+50E0 5109
+50E1 528D
+50E2 6AA2
+50E3 77BC
+50E4 9ED4
+50E5 52AB
+50E6 602F
+50E7 5048
+50E8 61A9
+50E9 63ED
+50EA 64CA
+50EB 683C
+50EC 6A84
+50ED 6FC0
+50EE 89A1
+50EF 9694
+50F0 9ABC
+50F1 5805
+50F2 80A9
+50F3 727D
+50F4 72AC
+50F5 7504
+50F6 7D79
+50F7 7E6D
+50F8 898B
+50F9 8B74
+50FA 9063
+50FB 9D51
+50FC 6F54
+50FD 6C7A
+50FE 7D50
+5141 7F3A
+5142 8A23
+5143 517C
+5144 614A
+5145 7B9D
+5146 84B9
+5147 8B19
+5148 938C
+5149 4EAC
+514A 50BE
+514B 52C1
+514C 52CD
+514D 537F
+514E 54FD
+514F 5883
+5150 5E9A
+5151 5F91
+5152 6176
+5153 66BB
+5154 6243
+5155 64CE
+5156 656C
+5157 666F
+5158 66F4
+5159 6897
+515A 6AA0
+515B 6D87
+515C 7085
+515D 71B2
+515E 749F
+515F 74CA
+5160 754A
+5161 75D9
+5162 786C
+5163 78EC
+5164 7ADF
+5165 7AF6
+5166 7D45
+5167 7D93
+5168 8015
+5169 803F
+516A 811B
+516B 8396
+516C 8B66
+516D 8F15
+516E 9015
+516F 93E1
+5170 9803
+5171 9838
+5172 9A5A
+5173 9BE8
+5174 4FC2
+5175 5553
+5176 5951
+5177 5B63
+5178 5C46
+5179 60B8
+517A 6212
+517B 6842
+517C 68B0
+517D 6EAA
+517E 754C
+517F 7678
+5180 78CE
+5181 F845
+5182 7A3D
+5183 7CFB
+5184 7E6B
+5185 7E7C
+5186 8A08
+5187 8AA1
+5188 968E
+5189 8C3F
+518A 96DE
+518B 9DC4
+518C 53E9
+518D 53E4
+518E 544A
+518F 5471
+5190 56FA
+5191 59D1
+5192 5B64
+5193 5EAB
+5194 62F7
+5195 6537
+5196 6545
+5197 6572
+5198 67AF
+5199 6772
+519A 6CBD
+519B 75FC
+519C 7690
+519D 8831
+519E 77BD
+519F 7A3F
+51A0 777E
+51A1 8003
+51A2 80A1
+51A3 818F
+51A4 82E6
+51A5 85C1
+51A6 88B4
+51A7 8A41
+51A8 8AA5
+51A9 F903
+51AA 8F9C
+51AB 932E
+51AC 96C7
+51AD 9867
+51AE 9AD8
+51AF 9F13
+51B0 54ED
+51B1 659B
+51B2 66F2
+51B3 688F
+51B4 7A40
+51B5 8C37
+51B6 9D60
+51B7 56F0
+51B8 5764
+51B9 5D11
+51BA 6606
+51BB 68B1
+51BC 68CD
+51BD 6EFE
+51BE 889E
+51BF 6C68
+51C0 F904
+51C1 9AA8
+51C2 4F9B
+51C3 516C
+51C4 5171
+51C5 529F
+51C6 5B54
+51C7 5DE5
+51C8 8CA2
+51C9 606D
+51CA 6050
+51CB 62F1
+51CC 63A7
+51CD 653B
+51CE 6831
+51CF 69D3
+51D0 7A7A
+51D1 7B9C
+51D2 5BE1
+51D3 6208
+51D4 679C
+51D5 74DC
+51D6 79D1
+51D7 83D3
+51D8 874C
+51D9 8A87
+51DA 8AB2
+51DB 904E
+51DC 9846
+51DD 5ED3
+51DE 69E8
+51DF 85FF
+51E0 90ED
+51E1 970D
+51E2 F905
+51E3 51A0
+51E4 5B98
+51E5 5BEC
+51E6 6163
+51E7 68FA
+51E8 74D8
+51E9 6B3E
+51EA 704C
+51EB 76E5
+51EC 7BA1
+51ED 7F50
+51EE 83C5
+51EF 89C0
+51F0 8CAB
+51F1 95DC
+51F2 9928
+51F3 9E1B
+51F4 522E
+51F5 605D
+51F6 62EC
+51F7 9002
+51F8 5149
+51F9 5321
+51FA 58D9
+51FB 5EE3
+51FC 66E0
+51FD 6D38
+51FE 72C2
+5241 73D6
+5242 7B50
+5243 80F1
+5244 945B
+5245 5366
+5246 639B
+5247 7F6B
+5248 4E56
+5249 5080
+524A 584A
+524B 58DE
+524C 602A
+524D 6127
+524E 62D0
+524F 69D0
+5250 9B41
+5251 5B8F
+5252 7D18
+5253 80B1
+5254 8F5F
+5255 4EA4
+5256 50D1
+5257 54AC
+5258 55AC
+5259 5B0C
+525A 5DA0
+525B 5DE7
+525C 654E
+525D 652A
+525E 6821
+525F 6A4B
+5260 72E1
+5261 768E
+5262 77EF
+5263 7D5E
+5264 7FF9
+5265 81A0
+5266 854E
+5267 86DF
+5268 8F03
+5269 8F4E
+526A 90CA
+526B 9278
+526C 9903
+526D 9A55
+526E 9BAB
+526F 4E18
+5270 4E45
+5271 4E5D
+5272 4EC7
+5273 4F5D
+5274 4FF1
+5275 50B4
+5276 5177
+5277 52FE
+5278 5340
+5279 53E3
+527A 53E5
+527B 548E
+527C 5614
+527D 57A2
+527E 5ABE
+527F 5AD7
+5280 5BC7
+5281 5D87
+5282 5ED0
+5283 61FC
+5284 62D8
+5285 6551
+5286 F846
+5287 67B8
+5288 67E9
+5289 69CB
+528A 6B50
+528B 6BC6
+528C 6BEC
+528D 6C42
+528E 6E9D
+528F 7078
+5290 72D7
+5291 7396
+5292 7403
+5293 750C
+5294 77BF
+5295 77E9
+5296 7A76
+5297 7D7F
+5298 8CFC
+5299 81FC
+529A 8205
+529B 820A
+529C 82DF
+529D 8862
+529E 89AF
+529F 8B33
+52A0 8EC0
+52A1 9011
+52A2 90B1
+52A3 9264
+52A4 98B6
+52A5 99D2
+52A6 9A45
+52A7 9CE9
+52A8 9DD7
+52A9 9F9C
+52AA 570B
+52AB 5C40
+52AC 63AC
+52AD 83CA
+52AE 97A0
+52AF 9EB4
+52B0 7A98
+52B1 7FA4
+52B2 8ECD
+52B3 541B
+52B4 90E1
+52B5 5800
+52B6 5C48
+52B7 6398
+52B8 7A9F
+52B9 5BAE
+52BA 5F13
+52BB 7A79
+52BC 7AAE
+52BD 8EAC
+52BE 5026
+52BF 5238
+52C0 52F8
+52C1 5377
+52C2 5708
+52C3 62F3
+52C4 6B0A
+52C5 7737
+52C6 53A5
+52C7 8E76
+52C8 95D5
+52C9 673A
+52CA 6AC3
+52CB 6F70
+52CC 8A6D
+52CD 8DEA
+52CE 8ECC
+52CF 994B
+52D0 6B78
+52D1 8CB4
+52D2 9B3C
+52D3 F907
+52D4 53EB
+52D5 572D
+52D6 594E
+52D7 63C6
+52D8 73EA
+52D9 7845
+52DA 7ABA
+52DB 8475
+52DC 7CFE
+52DD 898F
+52DE 8D73
+52DF 9035
+52E0 95A8
+52E1 5747
+52E2 7B60
+52E3 83CC
+52E4 921E
+52E5 F908
+52E6 6A58
+52E7 514B
+52E8 524B
+52E9 5287
+52EA 621F
+52EB 6975
+52EC 68D8
+52ED 9699
+52EE 50C5
+52EF 52E4
+52F0 5DF9
+52F1 61C3
+52F2 65A4
+52F3 6839
+52F4 69FF
+52F5 6F0C
+52F6 747E
+52F7 7B4B
+52F8 82B9
+52F9 83EB
+52FA 89B2
+52FB 8B39
+52FC 8FD1
+52FD 9949
+52FE F909
+5341 4ECA
+5342 64D2
+5343 6A8E
+5344 7434
+5345 7981
+5346 79BD
+5347 887F
+5348 887E
+5349 895F
+534A F90A
+534B 9326
+534C 53CA
+534D 5C8C
+534E 6025
+534F 6271
+5350 6C72
+5351 7B08
+5352 7D1A
+5353 7D66
+5354 4E98
+5355 5162
+5356 77DC
+5357 80AF
+5358 4F01
+5359 4F0E
+535A 5176
+535B 5180
+535C 55DC
+535D 5668
+535E 573B
+535F 57FA
+5360 5914
+5361 5947
+5362 5993
+5363 5BC4
+5364 5C90
+5365 8C48
+5366 5D0E
+5367 5E7E
+5368 5DF1
+5369 5FCC
+536A 6280
+536B 65D7
+536C 65E3
+536D 671F
+536E 675E
+536F 68CB
+5370 68C4
+5371 6A5F
+5372 6B3A
+5373 6C23
+5374 6C7D
+5375 6C82
+5376 6DC7
+5377 7426
+5378 742A
+5379 74A3
+537A 7578
+537B 757F
+537C 7881
+537D 78EF
+537E 7947
+537F 7948
+5380 797A
+5381 7B95
+5382 7D00
+5383 7DBA
+5384 F847
+5385 8006
+5386 802D
+5387 808C
+5388 671E
+5389 8A18
+538A 8B4F
+538B 8D77
+538C 9321
+538D 98E2
+538E 9951
+538F 9A0E
+5390 9A0F
+5391 9A65
+5392 9C2D
+5393 9E92
+5394 7DCA
+5395 4F76
+5396 5409
+5397 62EE
+5398 6854
+5399 91D1
+539A F848
+539B 55AB
+539C 513A
+539D 61E6
+539E 62CF
+539F 62FF
+53A0 7CEF
+53A1 90A3
+53A2 8AFE
+53A3 6696
+53A4 7156
+53A5 96E3
+53A6 637A
+53A7 634F
+53A8 5357
+53A9 5583
+53AA 7537
+53AB 7D0D
+53AC 56CA
+53AD 5A18
+53AE 66E9
+53AF 4E43
+53B0 5167
+53B1 5948
+53B2 67F0
+53B3 8010
+53B4 8FFA
+53B5 5973
+53B6 5E74
+53B7 79CA
+53B8 5FF5
+53B9 606C
+53BA 62C8
+53BB 637B
+53BC 4F5E
+53BD 5BE7
+53BE F849
+53BF 52AA
+53C0 5974
+53C1 5B65
+53C2 5F29
+53C3 6012
+53C4 7459
+53C5 6FC3
+53C6 81BF
+53C7 8FB2
+53C8 60F1
+53C9 8166
+53CA 5C3F
+53CB F84A
+53CC 5AE9
+53CD 8A25
+53CE 7D10
+53CF 80FD
+53D0 5C3C
+53D1 6CE5
+53D2 533F
+53D3 6EBA
+53D4 591A
+53D5 8336
+53D6 4E39
+53D7 4F46
+53D8 55AE
+53D9 5718
+53DA 58C7
+53DB 65B7
+53DC 65E6
+53DD 6A80
+53DE 6BB5
+53DF 6E4D
+53E0 77ED
+53E1 7AEF
+53E2 7C1E
+53E3 7DDE
+53E4 86CB
+53E5 8892
+53E6 9132
+53E7 935B
+53E8 977C
+53E9 601B
+53EA 64BB
+53EB 737A
+53EC 75B8
+53ED 9054
+53EE 95E5
+53EF 97C3
+53F0 5556
+53F1 64D4
+53F2 66C7
+53F3 6DE1
+53F4 6F6D
+53F5 6FB9
+53F6 75F0
+53F7 8043
+53F8 81BD
+53F9 8983
+53FA 8AC7
+53FB 8B5A
+53FC 6C93
+53FD 7B54
+53FE 8E0F
+5441 905D
+5442 515A
+5443 5802
+5444 5858
+5445 5E62
+5446 5510
+5447 649E
+5448 68E0
+5449 7576
+544A 7CD6
+544B 87F7
+544C 9EE8
+544D 4EE3
+544E 5788
+544F 5927
+5450 5C0D
+5451 5CB1
+5452 5E36
+5453 5F85
+5454 6234
+5455 64E1
+5456 73B3
+5457 7893
+5458 81FA
+5459 888B
+545A 8CB8
+545B 968A
+545C 9EDB
+545D 5B85
+545E 5FB7
+545F 60B3
+5460 5012
+5461 5200
+5462 5230
+5463 5716
+5464 5835
+5465 5857
+5466 5C0E
+5467 5C60
+5468 5CF6
+5469 5EA6
+546A 5F92
+546B 60BC
+546C 6311
+546D 6417
+546E 6843
+546F 68F9
+5470 6DD8
+5471 6E21
+5472 6ED4
+5473 6FE4
+5474 71FE
+5475 76DC
+5476 7779
+5477 79B1
+5478 7A3B
+5479 8404
+547A 83DF
+547B 8CED
+547C 8DF3
+547D 8E48
+547E 9003
+547F 9014
+5480 9053
+5481 90FD
+5482 934D
+5483 9676
+5484 97DC
+5485 6BD2
+5486 7006
+5487 7258
+5488 72A2
+5489 7368
+548A 7763
+548B 79BF
+548C 7BE4
+548D 7E9B
+548E 8B80
+548F 58A9
+5490 60C7
+5491 6566
+5492 66BE
+5493 6C8C
+5494 71C9
+5495 8C5A
+5496 9813
+5497 5484
+5498 4E6D
+5499 7A81
+549A 4EDD
+549B 51AC
+549C 51CD
+549D 52D5
+549E 540C
+549F 578C
+54A0 61A7
+54A1 6771
+54A2 6850
+54A3 68DF
+54A4 6D1E
+54A5 6F7C
+54A6 7AE5
+54A7 75BC
+54A8 77B3
+54A9 8463
+54AA 80F4
+54AB 9285
+54AC 515C
+54AD 6597
+54AE 675C
+54AF 6793
+54B0 75D8
+54B1 7AC7
+54B2 8373
+54B3 809A
+54B4 86AA
+54B5 F95A
+54B6 8C46
+54B7 982D
+54B8 5C6F
+54B9 81C0
+54BA 9041
+54BB 906F
+54BC 920D
+54BD 5F97
+54BE 6A59
+54BF 6ED5
+54C0 706F
+54C1 71C8
+54C2 767B
+54C3 7B49
+54C4 85E4
+54C5 8B04
+54C6 9127
+54C7 9419
+54C8 9A30
+54C9 5587
+54CA 61F6
+54CB 7669
+54CC 7F85
+54CD 863F
+54CE 87BA
+54CF 88F8
+54D0 908F
+54D1 F95C
+54D2 6D1B
+54D3 70D9
+54D4 7296
+54D5 73DE
+54D6 7D61
+54D7 843D
+54D8 916A
+54D9 99F1
+54DA 4E82
+54DB 5375
+54DC 5E71
+54DD 6B04
+54DE 6B12
+54DF 703E
+54E0 721B
+54E1 862D
+54E2 9E1E
+54E3 524C
+54E4 57D3
+54E5 8FA3
+54E6 5D50
+54E7 64E5
+54E8 652C
+54E9 6B16
+54EA 6FEB
+54EB 7C43
+54EC 7E9C
+54ED 85CD
+54EE 8964
+54EF 89BD
+54F0 62C9
+54F1 81D8
+54F2 881F
+54F3 5ECA
+54F4 6717
+54F5 6994
+54F6 6D6A
+54F7 72FC
+54F8 7405
+54F9 746F
+54FA 8782
+54FB 90DE
+54FC 4F86
+54FD 840A
+54FE 51B7
+5541 63A0
+5542 7565
+5543 4EAE
+5544 5169
+5545 5006
+5546 51C9
+5547 6881
+5548 6DBC
+5549 6A11
+554A 7CAE
+554B 7CB1
+554C 7CE7
+554D 826F
+554E 8AD2
+554F 8F1B
+5550 91CF
+5551 9B4E
+5552 4FB6
+5553 52F5
+5554 5442
+5555 5EEC
+5556 623E
+5557 65C5
+5558 6ADA
+5559 6FFE
+555A 7658
+555B 792A
+555C 8182
+555D 85DC
+555E 616E
+555F 8823
+5560 8821
+5561 9462
+5562 95AD
+5563 9A62
+5564 9A6A
+5565 9E97
+5566 9ECE
+5567 529B
+5568 6B77
+5569 66C6
+556A 6ADF
+556B 701D
+556C 792B
+556D 8F62
+556E 9742
+556F 6190
+5570 6200
+5571 6523
+5572 6F23
+5573 7149
+5574 7DF4
+5575 806F
+5576 84EE
+5577 8F26
+5578 9023
+5579 934A
+557A 51BD
+557B 52A3
+557C 5217
+557D 6D0C
+557E 70C8
+557F 88C2
+5580 5EC9
+5581 6582
+5582 6BAE
+5583 6FC2
+5584 7C3E
+5585 7375
+5586 9B23
+5587 4EE4
+5588 4F36
+5589 56F9
+558A 5DBA
+558B 601C
+558C 6624
+558D 6CE0
+558E 73B2
+558F 7F9A
+5590 7FCE
+5591 82D3
+5592 86C9
+5593 901E
+5594 96F6
+5595 9748
+5596 9234
+5597 9818
+5598 9F61
+5599 4F8B
+559A 79AE
+559B 91B4
+559C 96B7
+559D 52DE
+559E 6488
+559F 6AD3
+55A0 6F66
+55A1 7210
+55A2 7018
+55A3 76E7
+55A4 8001
+55A5 826B
+55A6 8606
+55A7 865C
+55A8 8DEF
+55A9 8F05
+55AA 8F64
+55AB 9732
+55AC 9B6F
+55AD 9DFA
+55AE 9E75
+55AF 6F09
+55B0 788C
+55B1 F84B
+55B2 7DA0
+55B3 8F46
+55B4 9304
+55B5 9E93
+55B6 9E7F
+55B7 8AD6
+55B8 58DF
+55B9 5F04
+55BA 6727
+55BB 7027
+55BC 74CF
+55BD 7C60
+55BE 807E
+55BF 5121
+55C0 7262
+55C1 78CA
+55C2 7C5F
+55C3 857E
+55C4 8A84
+55C5 8CF4
+55C6 8CC2
+55C7 96F7
+55C8 4E86
+55C9 50DA
+55CA F84C
+55CB 5BEE
+55CC 5ED6
+55CD 71CE
+55CE 7642
+55CF 77AD
+55D0 6599
+55D1 804A
+55D2 84FC
+55D3 907C
+55D4 9F8D
+55D5 50C2
+55D6 58D8
+55D7 5C62
+55D8 6A13
+55D9 6DDA
+55DA 6F0F
+55DB 7D2F
+55DC 7E37
+55DD 8938
+55DE 964B
+55DF 9ACF
+55E0 5289
+55E1 67F3
+55E2 69B4
+55E3 6D41
+55E4 6E9C
+55E5 7409
+55E6 7460
+55E7 7559
+55E8 7624
+55E9 786B
+55EA 8B2C
+55EB 985E
+55EC 516D
+55ED 622E
+55EE 9678
+55EF 502B
+55F0 5D19
+55F1 6DEA
+55F2 7DB8
+55F3 8F2A
+55F4 5F8B
+55F5 6144
+55F6 6817
+55F7 F961
+55F8 7ABF
+55F9 9686
+55FA 808B
+55FB 52D2
+55FC 51DB
+55FD 5EE9
+55FE 51CC
+5641 695E
+5642 7A1C
+5643 7DBE
+5644 83F1
+5645 9675
+5646 4FDA
+5647 5229
+5648 5398
+5649 540F
+564A 5C65
+564B 60A7
+564C F84D
+564D 674E
+564E 68A8
+564F 6F13
+5650 7281
+5651 72F8
+5652 7406
+5653 7483
+5654 75E2
+5655 79BB
+5656 7F79
+5657 7C6C
+5658 87AD
+5659 88CF
+565A 91CC
+565B 91D0
+565C 96E2
+565D 9B51
+565E 9BC9
+565F 541D
+5660 71D0
+5661 7498
+5662 85FA
+5663 8EAA
+5664 96A3
+5665 9C57
+5666 9E9F
+5667 6797
+5668 6DCB
+5669 7433
+566A 75F3
+566B 81E8
+566C 9716
+566D 5CA6
+566E 782C
+566F 7ACB
+5670 7B20
+5671 7C92
+5672 5ABD
+5673 6469
+5674 746A
+5675 75F2
+5676 78E8
+5677 87C7
+5678 99AC
+5679 9B54
+567A 9EBB
+567B 5BDE
+567C 5E55
+567D 6F20
+567E 819C
+567F 83AB
+5680 5A29
+5681 5DD2
+5682 5F4E
+5683 6162
+5684 633D
+5685 6669
+5686 66FC
+5687 6EFF
+5688 6F2B
+5689 7063
+568A 779E
+568B 842C
+568C 8513
+568D 883B
+568E 8B3E
+568F 8F13
+5690 93DD
+5691 9945
+5692 9B18
+5693 9C3B
+5694 62B9
+5695 672B
+5696 6CAB
+5697 896A
+5698 977A
+5699 4EA1
+569A 5984
+569B 5FD8
+569C 5FD9
+569D 671B
+569E 7DB2
+569F 7F54
+56A0 8292
+56A1 832B
+56A2 83BD
+56A3 9099
+56A4 9B4D
+56A5 57CB
+56A6 59B9
+56A7 5A92
+56A8 5BD0
+56A9 6627
+56AA 679A
+56AB 6885
+56AC 6BCF
+56AD 7164
+56AE 771B
+56AF 7F75
+56B0 82FA
+56B1 8CB7
+56B2 8CE3
+56B3 9081
+56B4 9B45
+56B5 8108
+56B6 8109
+56B7 8C8A
+56B8 964C
+56B9 9A40
+56BA 9EA5
+56BB 5B5F
+56BC 6C13
+56BD 731B
+56BE 76DF
+56BF 76F2
+56C0 840C
+56C1 51AA
+56C2 8993
+56C3 4FDB
+56C4 514D
+56C5 52C9
+56C6 5195
+56C7 68C9
+56C8 7704
+56C9 7720
+56CA 7DBF
+56CB 7DEC
+56CC 9762
+56CD 9EB5
+56CE 6EC5
+56CF 8511
+56D0 547D
+56D1 51A5
+56D2 540D
+56D3 9CF4
+56D4 660E
+56D5 669D
+56D6 6E9F
+56D7 76BF
+56D8 8317
+56D9 879F
+56DA 9169
+56DB 9298
+56DC 8882
+56DD 4FAE
+56DE 52DF
+56DF 5E3D
+56E0 59C6
+56E1 6155
+56E2 6478
+56E3 66AE
+56E4 5192
+56E5 67D0
+56E6 6A21
+56E7 6BCD
+56E8 6BDB
+56E9 725F
+56EA 7261
+56EB 7738
+56EC 77DB
+56ED 8004
+56EE 8017
+56EF 8305
+56F0 8B00
+56F1 8B28
+56F2 8C8C
+56F3 927E
+56F4 6728
+56F5 6C90
+56F6 7267
+56F7 76EE
+56F8 7766
+56F9 7A46
+56FA 6B7F
+56FB 6C92
+56FC 5922
+56FD 6726
+56FE 6FDB
+5741 77C7
+5742 8499
+5743 536F
+5744 5893
+5745 5999
+5746 5EDF
+5747 63CF
+5748 6634
+5749 6773
+574A 6E3A
+574B 732B
+574C 82D7
+574D 9328
+574E 52D9
+574F 5DEB
+5750 61CB
+5751 620A
+5752 62C7
+5753 64AB
+5754 65E0
+5755 6B66
+5756 6BCB
+5757 7121
+5758 755D
+5759 7E46
+575A 821E
+575B 8302
+575C 856A
+575D 8AA3
+575E 8CBF
+575F 9727
+5760 9D61
+5761 58A8
+5762 9ED8
+5763 520E
+5764 543B
+5765 6587
+5766 6C76
+5767 7D0B
+5768 7D0A
+5769 868A
+576A 9580
+576B 554F
+576C 805E
+576D 52FF
+576E 7269
+576F 5473
+5770 5A9A
+5771 5C3E
+5772 5D4B
+5773 9761
+5774 5F4C
+5775 5FAE
+5776 672A
+5777 6E3C
+5778 7030
+5779 7709
+577A 7C73
+577B 7CDC
+577C 7F8E
+577D 8587
+577E 8B0E
+577F 8FF7
+5780 60B6
+5781 610D
+5782 61AB
+5783 654F
+5784 65FC
+5785 65FB
+5786 6C11
+5787 6CEF
+5788 739F
+5789 73C9
+578A 9594
+578B 95A9
+578C 5BC6
+578D 871C
+578E 8B10
+578F F84E
+5790 525D
+5791 535A
+5792 62CD
+5793 640F
+5794 64B2
+5795 6734
+5796 6A38
+5797 6B02
+5798 6CCA
+5799 7254
+579A 73C0
+579B 749E
+579C 7B94
+579D 7E1B
+579E 7C95
+579F 818A
+57A0 8236
+57A1 8584
+57A2 8FEB
+57A3 96F9
+57A4 99C1
+57A5 4F34
+57A6 534A
+57A7 53CD
+57A8 53DB
+57A9 62CC
+57AA 642C
+57AB 6500
+57AC 6591
+57AD 69C3
+57AE 6F58
+57AF 6CEE
+57B0 73ED
+57B1 7554
+57B2 76E4
+57B3 78FB
+57B4 792C
+57B5 7D46
+57B6 80D6
+57B7 87E0
+57B8 822C
+57B9 8FD4
+57BA 9812
+57BB 98EF
+57BC 52C3
+57BD 62D4
+57BE 6F51
+57BF 64A5
+57C0 767C
+57C1 8DCB
+57C2 91B1
+57C3 9262
+57C4 9AEE
+57C5 9B43
+57C6 5023
+57C7 508D
+57C8 574A
+57C9 59A8
+57CA 5C28
+57CB 5E47
+57CC 5F77
+57CD 623F
+57CE 653E
+57CF 65B9
+57D0 65C1
+57D1 6609
+57D2 699C
+57D3 7D21
+57D4 80AA
+57D5 8180
+57D6 822B
+57D7 82B3
+57D8 84A1
+57D9 868C
+57DA 8A2A
+57DB 8B17
+57DC 90A6
+57DD 9632
+57DE 9AE3
+57DF 9B74
+57E0 9F90
+57E1 4FF3
+57E2 500D
+57E3 F963
+57E4 57F9
+57E5 5F98
+57E6 62DC
+57E7 6392
+57E8 676F
+57E9 6E43
+57EA 76C3
+57EB 80DA
+57EC 80CC
+57ED 88F5
+57EE 88F4
+57EF 8919
+57F0 8CE0
+57F1 8F29
+57F2 914D
+57F3 966A
+57F4 4F2F
+57F5 4F70
+57F6 5E1B
+57F7 67CF
+57F8 6822
+57F9 767D
+57FA 767E
+57FB 9B44
+57FC 6A0A
+57FD F84F
+57FE 7169
+5841 756A
+5842 F964
+5843 7E41
+5844 7FFB
+5845 8543
+5846 85E9
+5847 98DC
+5848 4F10
+5849 7B4F
+584A 7F70
+584B 95A5
+584C 51E1
+584D 5E06
+584E 68B5
+584F 6C3E
+5850 6C4E
+5851 6CDB
+5852 72AF
+5853 7BC4
+5854 8303
+5855 6CD5
+5856 743A
+5857 50FB
+5858 5288
+5859 58C1
+585A 64D8
+585B 74A7
+585C 7656
+585D 78A7
+585E 8F9F
+585F 95E2
+5860 9739
+5861 F965
+5862 535E
+5863 5F01
+5864 6C74
+5865 8FAE
+5866 8B8A
+5867 8FA8
+5868 8FAF
+5869 F850
+586A 908A
+586B 99E2
+586C 5225
+586D 5F46
+586E 77A5
+586F 9C49
+5870 9F08
+5871 4E19
+5872 5002
+5873 5175
+5874 5C5B
+5875 5E77
+5876 661E
+5877 663A
+5878 67C4
+5879 70B3
+587A 7501
+587B 75C5
+587C 7ADD
+587D 79C9
+587E 8F27
+587F 8FF8
+5880 9920
+5881 4FDD
+5882 5821
+5883 5831
+5884 5BF6
+5885 666E
+5886 6B65
+5887 6E7A
+5888 6D11
+5889 6F7D
+588A 752B
+588B 88DC
+588C 8913
+588D 8B5C
+588E 8F14
+588F 9D07
+5890 9EFC
+5891 4F0F
+5892 50D5
+5893 5310
+5894 535C
+5895 5B93
+5896 5FA9
+5897 798F
+5898 670D
+5899 8179
+589A 832F
+589B 8514
+589C 8986
+589D 8760
+589E 8907
+589F 8F3B
+58A0 99A5
+58A1 9C12
+58A2 672C
+58A3 4E76
+58A4 4E30
+58A5 4FF8
+58A6 5949
+58A7 5C01
+58A8 5CF0
+58A9 5CEF
+58AA 6367
+58AB 742B
+58AC 68D2
+58AD 70FD
+58AE 7E2B
+58AF 8451
+58B0 84EC
+58B1 8702
+58B2 9022
+58B3 92D2
+58B4 9CF3
+58B5 4EC6
+58B6 4ED8
+58B7 5085
+58B8 5256
+58B9 526F
+58BA 5426
+58BB 57E0
+58BC 592B
+58BD 5A66
+58BE 5B75
+58BF 5BCC
+58C0 5E9C
+58C1 F966
+58C2 6276
+58C3 6577
+58C4 65A7
+58C5 6D6E
+58C6 6EA5
+58C7 7236
+58C8 7C3F
+58C9 7F36
+58CA 7B26
+58CB 7F58
+58CC 8151
+58CD 8150
+58CE 819A
+58CF 8299
+58D0 82FB
+58D1 8709
+58D2 8A03
+58D3 8CA0
+58D4 8CE6
+58D5 8CFB
+58D6 8D74
+58D7 8DBA
+58D8 90E8
+58D9 91DC
+58DA 961C
+58DB 9644
+58DC 982B
+58DD 99D9
+58DE 9B92
+58DF 9CE7
+58E0 5317
+58E1 5206
+58E2 5674
+58E3 F851
+58E4 58B3
+58E5 5954
+58E6 596E
+58E7 5FFF
+58E8 61A4
+58E9 626E
+58EA 6C7E
+58EB 711A
+58EC 76C6
+58ED 7C89
+58EE 7CDE
+58EF 7D1B
+58F0 82AC
+58F1 8561
+58F2 96F0
+58F3 F967
+58F4 4F5B
+58F5 F852
+58F6 5F17
+58F7 62C2
+58F8 9AF4
+58F9 9EFB
+58FA 5D29
+58FB 670B
+58FC 68DA
+58FD 787C
+58FE 7E43
+5941 9D6C
+5942 4E15
+5943 5099
+5944 5315
+5945 532A
+5946 5351
+5947 5983
+5948 59A3
+5949 5A62
+594A 5E87
+594B 60B2
+594C 618A
+594D 6249
+594E 6279
+594F 6590
+5950 F853
+5951 69A7
+5952 6C98
+5953 F968
+5954 6CB8
+5955 6BD4
+5956 6BD8
+5957 7435
+5958 75FA
+5959 7765
+595A 7812
+595B 7891
+595C 79D8
+595D 7BE6
+595E 7DCB
+595F 7FE1
+5960 80A5
+5961 8153
+5962 813E
+5963 81C2
+5964 83F2
+5965 871A
+5966 88E8
+5967 8AB9
+5968 8B6C
+5969 8CBB
+596A 8F61
+596B 9119
+596C 975E
+596D 98DB
+596E 9AC0
+596F 9F3B
+5970 5B2A
+5971 8CD3
+5972 5F6C
+5973 64EF
+5974 658C
+5975 6AB3
+5976 6BAF
+5977 6FF1
+5978 7015
+5979 725D
+597A 860B
+597B 8CA7
+597C F854
+597D 983B
+597E 9870
+597F 9B22
+5980 6191
+5981 6C37
+5982 8058
+5983 9A01
+5984 4E4D
+5985 4E8B
+5986 4E9B
+5987 4ED5
+5988 4F3C
+5989 4F3A
+598A 820D
+598B 4F7F
+598C 50FF
+598D 53F2
+598E 53F8
+598F 56DB
+5990 5506
+5991 55E3
+5992 58EB
+5993 5962
+5994 59D2
+5995 5A11
+5996 5BEB
+5997 5BFA
+5998 5DF3
+5999 5E2B
+599A F855
+599B 5F99
+599C 601D
+599D 6368
+599E 8D66
+599F 65AF
+59A0 659C
+59A1 67FB
+59A2 68AD
+59A3 6942
+59A4 69CE
+59A5 6C99
+59A6 6CD7
+59A7 6E23
+59A8 7009
+59A9 90AA
+59AA 7345
+59AB 7940
+59AC 793E
+59AD 7960
+59AE 6B7B
+59AF 7802
+59B0 79C1
+59B1 7B25
+59B2 7BE9
+59B3 84D1
+59B4 7D17
+59B5 7D72
+59B6 838E
+59B7 86C7
+59B8 88DF
+59B9 8A50
+59BA 8A5E
+59BB 8B1D
+59BC 8CDC
+59BD 5C04
+59BE 8FAD
+59BF 8086
+59C0 98FC
+59C1 99DF
+59C2 524A
+59C3 F969
+59C4 69CA
+59C5 6714
+59C6 F96A
+59C7 9460
+59C8 5098
+59C9 522A
+59CA 5C71
+59CB 6563
+59CC 6C55
+59CD 73CA
+59CE 7523
+59CF 759D
+59D0 7B97
+59D1 849C
+59D2 9178
+59D3 6492
+59D4 6BBA
+59D5 4E77
+59D6 85A9
+59D7 4E09
+59D8 F96B
+59D9 6749
+59DA 68EE
+59DB 6E17
+59DC 886B
+59DD 829F
+59DE 8518
+59DF 6B43
+59E0 63F7
+59E1 6F81
+59E2 98AF
+59E3 9364
+59E4 970E
+59E5 4E0A
+59E6 50B7
+59E7 50CF
+59E8 511F
+59E9 5546
+59EA 55AA
+59EB 5617
+59EC 723D
+59ED 5B40
+59EE 5C19
+59EF 5E8A
+59F0 5EA0
+59F1 5EC2
+59F2 5E38
+59F3 60F3
+59F4 76F8
+59F5 6851
+59F6 6A61
+59F7 6BA4
+59F8 6E58
+59F9 72C0
+59FA 7240
+59FB 7965
+59FC 7BB1
+59FD 7FD4
+59FE 88F3
+5A41 89F4
+5A42 8C61
+5A43 8CDE
+5A44 8A73
+5A45 971C
+5A46 585E
+5A47 74BD
+5A48 8CFD
+5A49 9C13
+5A4A F96C
+5A4B 7A61
+5A4C 7D22
+5A4D 8272
+5A4E 7272
+5A4F 751F
+5A50 7525
+5A51 F96D
+5A52 7B19
+5A53 566C
+5A54 58FB
+5A55 5885
+5A56 5A7F
+5A57 7280
+5A58 5DBC
+5A59 5E8F
+5A5A 5EB6
+5A5B 5F90
+5A5C 6055
+5A5D 6292
+5A5E 654D
+5A5F 6691
+5A60 66D9
+5A61 66F8
+5A62 6816
+5A63 68F2
+5A64 745E
+5A65 7D6E
+5A66 7DD6
+5A67 7F72
+5A68 80E5
+5A69 8212
+5A6A 85AF
+5A6B 897F
+5A6C 8A93
+5A6D 92E4
+5A6E 901D
+5A6F 9ECD
+5A70 F856
+5A71 9F20
+5A72 5915
+5A73 596D
+5A74 F857
+5A75 5E2D
+5A76 60DC
+5A77 6614
+5A78 6673
+5A79 6790
+5A7A 6C50
+5A7B 6DC5
+5A7C 6F5F
+5A7D 77F3
+5A7E 78A9
+5A7F 84C6
+5A80 91CB
+5A81 932B
+5A82 5148
+5A83 4ED9
+5A84 50CA
+5A85 F858
+5A86 5584
+5A87 5BA3
+5A88 5C20
+5A89 6103
+5A8A 6247
+5A8B 65CB
+5A8C F859
+5A8D 717D
+5A8E 71F9
+5A8F 79AA
+5A90 7444
+5A91 7487
+5A92 74BF
+5A93 766C
+5A94 7DDA
+5A95 7E55
+5A96 7FA8
+5A97 817A
+5A98 81B3
+5A99 8239
+5A9A 861A
+5A9B 87EC
+5A9C 8A75
+5A9D 8DE3
+5A9E 9078
+5A9F 9291
+5AA0 F85A
+5AA1 9BAE
+5AA2 5070
+5AA3 5368
+5AA4 820C
+5AA5 F85B
+5AA6 5C51
+5AA7 6308
+5AA8 6954
+5AA9 6D29
+5AAA 6E2B
+5AAB 859B
+5AAC 8A2D
+5AAD 8AAA
+5AAE 96EA
+5AAF 6BB2
+5AB0 7E96
+5AB1 87FE
+5AB2 8D0D
+5AB3 66B9
+5AB4 9583
+5AB5 71EE
+5AB6 651D
+5AB7 6D89
+5AB8 F96E
+5AB9 57CE
+5ABA 59D3
+5ABB 6027
+5ABC 60FA
+5ABD 6210
+5ABE 661F
+5ABF 665F
+5AC0 7329
+5AC1 76DB
+5AC2 7701
+5AC3 7B6C
+5AC4 8056
+5AC5 8072
+5AC6 8165
+5AC7 8AA0
+5AC8 9192
+5AC9 4E16
+5ACA 52E2
+5ACB 6B72
+5ACC 6D17
+5ACD 7A05
+5ACE 7B39
+5ACF 7D30
+5AD0 F96F
+5AD1 8CB0
+5AD2 53EC
+5AD3 562F
+5AD4 5851
+5AD5 5C0F
+5AD6 5C11
+5AD7 5BB5
+5AD8 5DE2
+5AD9 6383
+5ADA 6414
+5ADB 6240
+5ADC 662D
+5ADD 68B3
+5ADE 6CBC
+5ADF 6D88
+5AE0 6EAF
+5AE1 701F
+5AE2 70A4
+5AE3 71D2
+5AE4 7526
+5AE5 758E
+5AE6 758F
+5AE7 7B11
+5AE8 7C2B
+5AE9 7D20
+5AEA 7D39
+5AEB 8258
+5AEC 852C
+5AED 856D
+5AEE 8607
+5AEF 8A34
+5AF0 900D
+5AF1 9061
+5AF2 90B5
+5AF3 92B7
+5AF4 9704
+5AF5 97F6
+5AF6 9A37
+5AF7 4FD7
+5AF8 5C6C
+5AF9 675F
+5AFA 7C9F
+5AFB 7E8C
+5AFC 901F
+5AFD 5B6B
+5AFE 640D
+5B41 905C
+5B42 7387
+5B43 87C0
+5B44 5B8B
+5B45 677E
+5B46 8A1F
+5B47 8AA6
+5B48 9001
+5B49 980C
+5B4A 5237
+5B4B F970
+5B4C 7051
+5B4D 7463
+5B4E 788E
+5B4F 9396
+5B50 8870
+5B51 91D7
+5B52 4FEE
+5B53 53D7
+5B54 53DF
+5B55 56DA
+5B56 55FD
+5B57 5782
+5B58 58FD
+5B59 5AC2
+5B5A 5B88
+5B5B F85C
+5B5C 5CAB
+5B5D 5E25
+5B5E 620D
+5B5F 6101
+5B60 624B
+5B61 6388
+5B62 641C
+5B63 6536
+5B64 6578
+5B65 666C
+5B66 6A39
+5B67 6B8A
+5B68 71E7
+5B69 6C34
+5B6A 6D19
+5B6B 6EB2
+5B6C 6F31
+5B6D 72E9
+5B6E 7378
+5B6F 795F
+5B70 7626
+5B71 7761
+5B72 F85D
+5B73 79C0
+5B74 7A57
+5B75 7AEA
+5B76 7CB9
+5B77 7D8F
+5B78 7DAC
+5B79 7E61
+5B7A 7F9E
+5B7B 8129
+5B7C 8331
+5B7D 8490
+5B7E 84DA
+5B7F 85EA
+5B80 8896
+5B81 8AB0
+5B82 8F38
+5B83 9042
+5B84 9083
+5B85 916C
+5B86 9296
+5B87 92B9
+5B88 968B
+5B89 96A8
+5B8A 96D6
+5B8B 9700
+5B8C 9808
+5B8D 9996
+5B8E 9AD3
+5B8F 9B1A
+5B90 53D4
+5B91 587E
+5B92 5919
+5B93 5B70
+5B94 5BBF
+5B95 6DD1
+5B96 719F
+5B97 8085
+5B98 83FD
+5B99 5FAA
+5B9A 6042
+5B9B 65EC
+5B9C 696F
+5B9D 6B89
+5B9E 6D35
+5B9F 6DF3
+5BA0 73E3
+5BA1 76FE
+5BA2 77AC
+5BA3 7B4D
+5BA4 7D14
+5BA5 8123
+5BA6 821C
+5BA7 8340
+5BA8 8A62
+5BA9 5DE1
+5BAA 9187
+5BAB 931E
+5BAC 9806
+5BAD 99B4
+5BAE 9D89
+5BAF 620C
+5BB0 8853
+5BB1 8FF0
+5BB2 5D07
+5BB3 5D27
+5BB4 5D69
+5BB5 745F
+5BB6 819D
+5BB7 8671
+5BB8 8768
+5BB9 62FE
+5BBA 6FD5
+5BBB 7FD2
+5BBC 8936
+5BBD 8972
+5BBE 4E1E
+5BBF 4E58
+5BC0 50E7
+5BC1 5347
+5BC2 627F
+5BC3 6607
+5BC4 52DD
+5BC5 7E69
+5BC6 8805
+5BC7 965E
+5BC8 4F8D
+5BC9 5319
+5BCA 557B
+5BCB 5636
+5BCC 59CB
+5BCD 5AA4
+5BCE F85E
+5BCF 5C38
+5BD0 5C4D
+5BD1 5E02
+5BD2 5F11
+5BD3 6043
+5BD4 65BD
+5BD5 662F
+5BD6 6642
+5BD7 67BE
+5BD8 67F4
+5BD9 731C
+5BDA 77E2
+5BDB 793A
+5BDC 8996
+5BDD 7DE6
+5BDE 7FC5
+5BDF 8494
+5BE0 84CD
+5BE1 8A69
+5BE2 8A66
+5BE3 8AE1
+5BE4 8C7A
+5BE5 57F4
+5BE6 5BD4
+5BE7 5F0F
+5BE8 606F
+5BE9 62ED
+5BEA 690D
+5BEB 6B96
+5BEC 6E5C
+5BED 7184
+5BEE 8B58
+5BEF 8EFE
+5BF0 98DF
+5BF1 98FE
+5BF2 4F38
+5BF3 4FE1
+5BF4 547B
+5BF5 5A20
+5BF6 5BB8
+5BF7 613C
+5BF8 65B0
+5BF9 6668
+5BFA 71FC
+5BFB 7533
+5BFC 77E7
+5BFD 795E
+5BFE 7D33
+5C41 814E
+5C42 81E3
+5C43 8398
+5C44 85AA
+5C45 8703
+5C46 8A0A
+5C47 8EAB
+5C48 8F9B
+5C49 F971
+5C4A 8FC5
+5C4B 5931
+5C4C 5BA4
+5C4D 5BE6
+5C4E 6089
+5C4F F85F
+5C50 5BE9
+5C51 5C0B
+5C52 5FC3
+5C53 F972
+5C54 6C81
+5C55 6DF1
+5C56 700B
+5C57 751A
+5C58 82AF
+5C59 4EC0
+5C5A 5341
+5C5B F973
+5C5C 96D9
+5C5D 6C0F
+5C5E 4E9E
+5C5F 4FC4
+5C60 5152
+5C61 5A25
+5C62 5CE8
+5C63 6211
+5C64 7259
+5C65 82BD
+5C66 86FE
+5C67 8859
+5C68 8A1D
+5C69 963F
+5C6A 96C5
+5C6B 9913
+5C6C 9D09
+5C6D 9D5D
+5C6E 580A
+5C6F 5CB3
+5C70 5DBD
+5C71 6115
+5C72 60E1
+5C73 63E1
+5C74 6A02
+5C75 6E25
+5C76 843C
+5C77 984E
+5C78 9F77
+5C79 5B89
+5C7A 5CB8
+5C7B 6309
+5C7C 664F
+5C7D 6848
+5C7E 773C
+5C7F 96C1
+5C80 8D0B
+5C81 978D
+5C82 9854
+5C83 9D08
+5C84 621E
+5C85 65A1
+5C86 8B01
+5C87 8ECB
+5C88 904F
+5C89 95BC
+5C8A 5D52
+5C8B 5DD6
+5C8C 5EB5
+5C8D 6697
+5C8E 764C
+5C8F 83F4
+5C90 8AF3
+5C91 95C7
+5C92 9EEF
+5C93 58D3
+5C94 62BC
+5C95 72CE
+5C96 9D28
+5C97 4EF0
+5C98 592E
+5C99 600F
+5C9A 663B
+5C9B 6B83
+5C9C 79E7
+5C9D 9785
+5C9E 9D26
+5C9F 5393
+5CA0 57C3
+5CA1 5D16
+5CA2 611B
+5CA3 6B38
+5CA4 6DAF
+5CA5 769A
+5CA6 66D6
+5CA7 788D
+5CA8 7919
+5CA9 827E
+5CAA 54C0
+5CAB 9698
+5CAC 9744
+5CAD 9749
+5CAE 5384
+5CAF 6396
+5CB0 6DB2
+5CB1 814B
+5CB2 9628
+5CB3 984D
+5CB4 6AFB
+5CB5 7F4C
+5CB6 9DAF
+5CB7 9E1A
+5CB8 4E5F
+5CB9 503B
+5CBA 51B6
+5CBB 591C
+5CBC F860
+5CBD 63F6
+5CBE 6930
+5CBF 723A
+5CC0 8036
+5CC1 F974
+5CC2 60F9
+5CC3 91CE
+5CC4 5F31
+5CC5 7BDB
+5CC6 7C65
+5CC7 7D04
+5CC8 82E5
+5CC9 846F
+5CCA 85E5
+5CCB 8E8D
+5CCC 4F6F
+5CCD 58E4
+5CCE 5B43
+5CCF 6059
+5CD0 63DA
+5CD1 6518
+5CD2 656D
+5CD3 6698
+5CD4 694A
+5CD5 6A23
+5CD6 6D0B
+5CD7 7001
+5CD8 716C
+5CD9 7A70
+5CDA 75D2
+5CDB 760D
+5CDC 7F8A
+5CDD 7F98
+5CDE 8944
+5CDF 8B93
+5CE0 91C0
+5CE1 967D
+5CE2 990A
+5CE3 5704
+5CE4 5FA1
+5CE5 6554
+5CE6 65BC
+5CE7 6F01
+5CE8 79A6
+5CE9 8A9E
+5CEA 99AD
+5CEB 9B5A
+5CEC 9F6C
+5CED 5104
+5CEE 61B6
+5CEF 6291
+5CF0 6A8D
+5CF1 81C6
+5CF2 5043
+5CF3 5830
+5CF4 5F66
+5CF5 7109
+5CF6 8A00
+5CF7 8AFA
+5CF8 5B7C
+5CF9 513C
+5CFA 56B4
+5CFB 5944
+5CFC 63A9
+5CFD 6DF9
+5CFE 5DAA
+5D41 696D
+5D42 605A
+5D43 4E88
+5D44 4F59
+5D45 5982
+5D46 6B5F
+5D47 6C5D
+5D48 8207
+5D49 9918
+5D4A 4EA6
+5D4B 57DF
+5D4C F861
+5D4D 5F79
+5D4E 6613
+5D4F 75AB
+5D50 7E79
+5D51 8B6F
+5D52 9006
+5D53 9A5B
+5D54 56A5
+5D55 5827
+5D56 59F8
+5D57 5A1F
+5D58 5BB4
+5D59 5EF6
+5D5A 6350
+5D5B F991
+5D5C 693D
+5D5D 6CBF
+5D5E 6D93
+5D5F 6D8E
+5D60 6DF5
+5D61 6F14
+5D62 70DF
+5D63 7136
+5D64 7159
+5D65 71C3
+5D66 71D5
+5D67 784F
+5D68 786F
+5D69 7B75
+5D6A 7DE3
+5D6B F862
+5D6C 81D9
+5D6D 8815
+5D6E 884D
+5D6F 8B8C
+5D70 8EDF
+5D71 925B
+5D72 9CF6
+5D73 F99E
+5D74 6085
+5D75 6D85
+5D76 71B1
+5D77 F9A1
+5D78 95B1
+5D79 53AD
+5D7A 5869
+5D7B 67D3
+5D7C 708E
+5D7D 7130
+5D7E 9E7D
+5D7F 82D2
+5D80 8276
+5D81 95BB
+5D82 995C
+5D83 9AE5
+5D84 66C4
+5D85 71C1
+5D86 8449
+5D87 584B
+5D88 5B30
+5D89 5F71
+5D8A 6620
+5D8B 668E
+5D8C 6979
+5D8D 69AE
+5D8E 6C38
+5D8F 6CF3
+5D90 6F41
+5D91 701B
+5D92 71DF
+5D93 745B
+5D94 F9AE
+5D95 74D4
+5D96 76C8
+5D97 7E93
+5D98 82F1
+5D99 8A60
+5D9A 8FCE
+5D9B 502A
+5D9C 5208
+5D9D 53E1
+5D9E 66F3
+5D9F 6FCA
+5DA0 730A
+5DA1 7768
+5DA2 777F
+5DA3 7FF3
+5DA4 82AE
+5DA5 854B
+5DA6 85DD
+5DA7 8602
+5DA8 88D4
+5DA9 8A63
+5DAA 8B7D
+5DAB 8C6B
+5DAC 92B3
+5DAD 9713
+5DAE 9810
+5DAF 4E94
+5DB0 4F0D
+5DB1 50B2
+5DB2 5348
+5DB3 5433
+5DB4 55DA
+5DB5 58BA
+5DB6 5967
+5DB7 5A1B
+5DB8 5BE4
+5DB9 609F
+5DBA F9B9
+5DBB 65FF
+5DBC 6664
+5DBD 68A7
+5DBE 6C5A
+5DBF 70CF
+5DC0 7352
+5DC1 8708
+5DC2 8AA4
+5DC3 9068
+5DC4 543E
+5DC5 5C4B
+5DC6 6C83
+5DC7 7344
+5DC8 7389
+5DC9 923A
+5DCA 5ABC
+5DCB 6EAB
+5DCC 7465
+5DCD 761F
+5DCE 7A69
+5DCF 8580
+5DD0 860A
+5DD1 9C2E
+5DD2 5140
+5DD3 58C5
+5DD4 74EE
+5DD5 7670
+5DD6 64C1
+5DD7 7515
+5DD8 7FC1
+5DD9 9095
+5DDA 96CD
+5DDB 6E26
+5DDC 74E6
+5DDD 7AA9
+5DDE 86D9
+5DDF 8778
+5DE0 8A1B
+5DE1 81E5
+5DE2 5A49
+5DE3 5B8C
+5DE4 5B9B
+5DE5 6D63
+5DE6 73A9
+5DE7 742C
+5DE8 7897
+5DE9 7DE9
+5DEA 7FEB
+5DEB 8155
+5DEC 839E
+5DED 8C4C
+5DEE 962E
+5DEF 9811
+5DF0 66F0
+5DF1 5F80
+5DF2 65FA
+5DF3 6789
+5DF4 6C6A
+5DF5 738B
+5DF6 502D
+5DF7 6B6A
+5DF8 77EE
+5DF9 5916
+5DFA 5DCD
+5DFB 7325
+5DFC 754F
+5DFD 50E5
+5DFE 51F9
+5E41 582F
+5E42 592D
+5E43 5996
+5E44 59DA
+5E45 5DA2
+5E46 62D7
+5E47 6416
+5E48 64FE
+5E49 66DC
+5E4A 8170
+5E4B F9BF
+5E4C 6A48
+5E4D 7464
+5E4E 7A88
+5E4F 7AAF
+5E50 7E47
+5E51 7E5E
+5E52 8000
+5E53 8558
+5E54 87EF
+5E55 8981
+5E56 8B20
+5E57 9059
+5E58 9080
+5E59 9952
+5E5A 8FB1
+5E5B 617E
+5E5C 6B32
+5E5D 6D74
+5E5E 8925
+5E5F 50AD
+5E60 52C7
+5E61 5BB9
+5E62 5EB8
+5E63 5197
+5E64 6995
+5E65 6E67
+5E66 6EB6
+5E67 7194
+5E68 7462
+5E69 7528
+5E6A 8073
+5E6B 8202
+5E6C 8338
+5E6D 84C9
+5E6E 86F9
+5E6F 8E0A
+5E70 9394
+5E71 93DE
+5E72 4F51
+5E73 5076
+5E74 512A
+5E75 53C8
+5E76 53CB
+5E77 53F3
+5E78 5401
+5E79 5B87
+5E7A 5BD3
+5E7B 5C24
+5E7C 4E8E
+5E7D 611A
+5E7E 6182
+5E7F 725B
+5E80 76C2
+5E81 7950
+5E82 7991
+5E83 79B9
+5E84 7FBD
+5E85 828B
+5E86 865E
+5E87 8FC2
+5E88 9047
+5E89 90F5
+5E8A 9685
+5E8B 96E8
+5E8C 96E9
+5E8D 65ED
+5E8E 6631
+5E8F 715C
+5E90 7A36
+5E91 90C1
+5E92 980A
+5E93 4E91
+5E94 F9C5
+5E95 6B9E
+5E96 8018
+5E97 82B8
+5E98 904B
+5E99 9695
+5E9A 96F2
+5E9B 97FB
+5E9C 71A8
+5E9D 851A
+5E9E 9B31
+5E9F 718A
+5EA0 96C4
+5EA1 5143
+5EA2 539F
+5EA3 54E1
+5EA4 5712
+5EA5 5713
+5EA6 7230
+5EA7 57A3
+5EA8 5A9B
+5EA9 5BC3
+5EAA 6028
+5EAB 613F
+5EAC 63F4
+5EAD 6E90
+5EAE 733F
+5EAF 7457
+5EB0 82D1
+5EB1 873F
+5EB2 8881
+5EB3 8F45
+5EB4 9060
+5EB5 9662
+5EB6 9858
+5EB7 9D1B
+5EB8 6708
+5EB9 8D8A
+5EBA 925E
+5EBB 4F4D
+5EBC 5049
+5EBD 50DE
+5EBE 5371
+5EBF 570D
+5EC0 59D4
+5EC1 5C09
+5EC2 5E43
+5EC3 6170
+5EC4 5A01
+5EC5 6E2D
+5EC6 7232
+5EC7 744B
+5EC8 7DEF
+5EC9 80C3
+5ECA 840E
+5ECB 8466
+5ECC 875F
+5ECD 885B
+5ECE 885E
+5ECF 8B02
+5ED0 9055
+5ED1 97CB
+5ED2 9B4F
+5ED3 4E73
+5ED4 6538
+5ED5 4F91
+5ED6 5112
+5ED7 516A
+5ED8 5E7C
+5ED9 552F
+5EDA 55A9
+5EDB 56FF
+5EDC 5B7A
+5EDD 5BA5
+5EDE 5E37
+5EDF 5E7D
+5EE0 5EBE
+5EE1 60A0
+5EE2 60DF
+5EE3 6109
+5EE4 6108
+5EE5 63C4
+5EE6 6709
+5EE7 67D4
+5EE8 67DA
+5EE9 6961
+5EEA 6CB9
+5EEB 6E38
+5EEC 6FE1
+5EED 7336
+5EEE 745C
+5EEF 7531
+5EF0 7652
+5EF1 7DAD
+5EF2 81FE
+5EF3 8438
+5EF4 8564
+5EF5 88D5
+5EF6 8A98
+5EF7 8ADB
+5EF8 8AED
+5EF9 8E42
+5EFA 8E30
+5EFB 904A
+5EFC 903E
+5EFD 907A
+5EFE 9149
+5F41 91C9
+5F42 936E
+5F43 9EDD
+5F44 6BD3
+5F45 8089
+5F46 80B2
+5F47 9B3B
+5F48 5141
+5F49 596B
+5F4A 5C39
+5F4B 6F64
+5F4C 73A7
+5F4D 80E4
+5F4E 958F
+5F4F 807F
+5F50 620E
+5F51 7D68
+5F52 878D
+5F53 57A0
+5F54 6069
+5F55 6147
+5F56 6ABC
+5F57 6BB7
+5F58 73E2
+5F59 9280
+5F5A 8ABE
+5F5B 96B1
+5F5C 9F66
+5F5D 4E59
+5F5E 541F
+5F5F 6DEB
+5F60 852D
+5F61 9670
+5F62 98EE
+5F63 97F3
+5F64 6339
+5F65 63D6
+5F66 6CE3
+5F67 9091
+5F68 51DD
+5F69 61C9
+5F6A 81BA
+5F6B 9DF9
+5F6C 4F9D
+5F6D 501A
+5F6E 5100
+5F6F 7591
+5F70 77E3
+5F71 5B9C
+5F72 610F
+5F73 61FF
+5F74 64EC
+5F75 6BC5
+5F76 7FA9
+5F77 8264
+5F78 87FB
+5F79 8863
+5F7A 8ABC
+5F7B 8B70
+5F7C 91AB
+5F7D 4E8C
+5F7E 4EE5
+5F7F 4F0A
+5F80 5937
+5F81 59E8
+5F82 5DF2
+5F83 8CB3
+5F84 5F1B
+5F85 5F5B
+5F86 6021
+5F87 F9E0
+5F88 682E
+5F89 723E
+5F8A 73E5
+5F8B 7570
+5F8C 75CD
+5F8D 79FB
+5F8E 800C
+5F8F 8033
+5F90 8351
+5F91 98F4
+5F92 990C
+5F93 9823
+5F94 7037
+5F95 7FFC
+5F96 76CA
+5F97 7FCA
+5F98 7FCC
+5F99 4EBA
+5F9A 4EC1
+5F9B 4EDE
+5F9C 5203
+5F9D 5370
+5F9E 54BD
+5F9F 56E0
+5FA0 59FB
+5FA1 5BC5
+5FA2 5F15
+5FA3 5FCD
+5FA4 6E6E
+5FA5 8A8D
+5FA6 976D
+5FA7 9777
+5FA8 4E00
+5FA9 4F7E
+5FAA 58F9
+5FAB 65E5
+5FAC 6EA2
+5FAD 9038
+5FAE 93B0
+5FAF 99B9
+5FB0 4EFB
+5FB1 58EC
+5FB2 598A
+5FB3 59D9
+5FB4 7A14
+5FB5 834F
+5FB6 8CC3
+5FB7 5165
+5FB8 4ECD
+5FB9 5B55
+5FBA 5269
+5FBB 4ED4
+5FBC 523A
+5FBD 54A8
+5FBE 59C9
+5FBF 59FF
+5FC0 5B50
+5FC1 5B5C
+5FC2 5B57
+5FC3 6063
+5FC4 6148
+5FC5 6ECB
+5FC6 7099
+5FC7 716E
+5FC8 7386
+5FC9 74F7
+5FCA 75B5
+5FCB 7725
+5FCC 78C1
+5FCD 7CA2
+5FCE 7D2B
+5FCF 8005
+5FD0 8014
+5FD1 81EA
+5FD2 8517
+5FD3 85C9
+5FD4 89DC
+5FD5 8AEE
+5FD6 8CC7
+5FD7 8D6D
+5FD8 96CC
+5FD9 4F5C
+5FDA 52FA
+5FDB 56BC
+5FDC 65AB
+5FDD 6628
+5FDE 67DE
+5FDF 707C
+5FE0 70B8
+5FE1 7235
+5FE2 7DBD
+5FE3 828D
+5FE4 914C
+5FE5 96C0
+5FE6 9D72
+5FE7 68E7
+5FE8 6B98
+5FE9 6F7A
+5FEA 76DE
+5FEB 5C91
+5FEC 66AB
+5FED 6F5B
+5FEE 6F5C
+5FEF 7BB4
+5FF0 7C2A
+5FF1 8695
+5FF2 8836
+5FF3 96DC
+5FF4 4E08
+5FF5 4ED7
+5FF6 5320
+5FF7 5834
+5FF8 58BB
+5FF9 596C
+5FFA 5D82
+5FFB 5E33
+5FFC 5E84
+5FFD 5F35
+5FFE 638C
+6041 66B2
+6042 6756
+6043 6A1F
+6044 6AA3
+6045 6B0C
+6046 6F3F
+6047 58EF
+6048 5C07
+6049 7246
+604A F9FA
+604B 7350
+604C 748B
+604D 7634
+604E 7AE0
+604F 7CA7
+6050 8178
+6051 81DF
+6052 838A
+6053 846C
+6054 8523
+6055 8594
+6056 85CF
+6057 88C5
+6058 88DD
+6059 8D13
+605A 91AC
+605B 9577
+605C 969C
+605D 518D
+605E 54C9
+605F 5728
+6060 5BB0
+6061 624D
+6062 6750
+6063 683D
+6064 6893
+6065 6ED3
+6066 707D
+6067 7E94
+6068 88C1
+6069 8CA1
+606A 8F09
+606B 9F4B
+606C 9F4E
+606D 722D
+606E 7B8F
+606F 8ACD
+6070 931A
+6071 4F4E
+6072 4F47
+6073 5132
+6074 5480
+6075 59D0
+6076 5E95
+6077 62B5
+6078 6775
+6079 67E2
+607A 696E
+607B 6A17
+607C 6CAE
+607D 6E1A
+607E 72D9
+607F 732A
+6080 75BD
+6081 7BB8
+6082 82E7
+6083 8457
+6084 85F7
+6085 86C6
+6086 8A5B
+6087 8C6C
+6088 8CAF
+6089 8E87
+608A 9019
+608B 90B8
+608C 52E3
+608D 5AE1
+608E 5BC2
+608F 6458
+6090 6575
+6091 6EF4
+6092 72C4
+6093 7684
+6094 7A4D
+6095 7B1B
+6096 7C4D
+6097 7CF4
+6098 7E3E
+6099 837B
+609A 8B2B
+609B 8CCA
+609C 8D64
+609D 8DE1
+609E 8E5F
+609F 8FEA
+60A0 8FF9
+60A1 9069
+60A2 50B3
+60A3 5168
+60A4 5178
+60A5 524D
+60A6 526A
+60A7 56C0
+60A8 5861
+60A9 5960
+60AA 5C08
+60AB 5C55
+60AC 5DD3
+60AD 5EDB
+60AE 609B
+60AF 6230
+60B0 6813
+60B1 6BBF
+60B2 6C08
+60B3 6FB1
+60B4 714E
+60B5 7530
+60B6 7538
+60B7 7672
+60B8 78DA
+60B9 7B8B
+60BA 7BAD
+60BB 7BC6
+60BC 7E8F
+60BD 7FE6
+60BE 8A6E
+60BF 8F3E
+60C0 8F49
+60C1 923F
+60C2 9293
+60C3 9322
+60C4 96FB
+60C5 985A
+60C6 986B
+60C7 991E
+60C8 5207
+60C9 622A
+60CA 6298
+60CB 6D59
+60CC 7A83
+60CD 7ACA
+60CE 7BC0
+60CF 7D76
+60D0 5360
+60D1 5CBE
+60D2 5E97
+60D3 6F38
+60D4 70B9
+60D5 9EDE
+60D6 7C98
+60D7 9711
+60D8 63A5
+60D9 647A
+60DA 6904
+60DB 8776
+60DC 4E01
+60DD 4E95
+60DE 4EAD
+60DF 505C
+60E0 5075
+60E1 5448
+60E2 59C3
+60E3 5E40
+60E4 5EF7
+60E5 5F81
+60E6 5B9A
+60E7 5EAD
+60E8 60C5
+60E9 633A
+60EA 653F
+60EB 6574
+60EC 65CC
+60ED 6676
+60EE 6678
+60EF 6883
+60F0 6968
+60F1 6B63
+60F2 6C40
+60F3 6DE8
+60F4 6E1F
+60F5 753A
+60F6 775B
+60F7 7887
+60F8 798E
+60F9 7A0B
+60FA 7A7D
+60FB 9756
+60FC 7CBE
+60FD 8247
+60FE 8A02
+6141 8AEA
+6142 8C9E
+6143 912D
+6144 914A
+6145 91D8
+6146 9266
+6147 9320
+6148 9706
+6149 975C
+614A 9802
+614B 9F0E
+614C 5236
+614D 5291
+614E 557C
+614F 5824
+6150 5E1D
+6151 5F1F
+6152 608C
+6153 63D0
+6154 6662
+6155 68AF
+6156 6FDF
+6157 7445
+6158 81CD
+6159 796D
+615A 7B2C
+615B 85BA
+615C 88FD
+615D 8AF8
+615E 8E36
+615F 8E44
+6160 918D
+6161 9664
+6162 969B
+6163 973D
+6164 984C
+6165 9F4A
+6166 4FCE
+6167 51CB
+6168 5146
+6169 52A9
+616A F863
+616B 5632
+616C 566A
+616D 5F14
+616E 5F6B
+616F 63AA
+6170 64CD
+6171 65E9
+6172 6641
+6173 66FA
+6174 66F9
+6175 671D
+6176 689D
+6177 68D7
+6178 69FD
+6179 6F15
+617A 6F6E
+617B 7167
+617C 71E5
+617D 722A
+617E 7681
+617F 773A
+6180 7956
+6181 795A
+6182 79DF
+6183 7A20
+6184 7A95
+6185 7AC8
+6186 7B0A
+6187 7C97
+6188 7CDF
+6189 7CF6
+618A 7D44
+618B 7D5B
+618C 7E70
+618D 8087
+618E 85FB
+618F 86A4
+6190 8A54
+6191 8ABF
+6192 8D99
+6193 8E81
+6194 9020
+6195 906D
+6196 91E3
+6197 963B
+6198 9BDB
+6199 9CE5
+619A 65CF
+619B 7C07
+619C 8DB3
+619D 93C3
+619E 5B58
+619F 5C0A
+61A0 5352
+61A1 62D9
+61A2 731D
+61A3 5027
+61A4 5B97
+61A5 5F9E
+61A6 616B
+61A7 68D5
+61A8 6A05
+61A9 6DD9
+61AA 742E
+61AB 7A2E
+61AC 7D42
+61AD 7D9C
+61AE 7E31
+61AF 816B
+61B0 8E35
+61B1 8E64
+61B2 937E
+61B3 9418
+61B4 4F50
+61B5 5750
+61B6 5DE6
+61B7 5EA7
+61B8 632B
+61B9 7F6A
+61BA 4E3B
+61BB 4F4F
+61BC 4F8F
+61BD 505A
+61BE 5EDA
+61BF 546A
+61C0 5468
+61C1 55FE
+61C2 594F
+61C3 5B99
+61C4 5DDE
+61C5 665D
+61C6 6731
+61C7 67F1
+61C8 682A
+61C9 70B7
+61CA 6CE8
+61CB 6D32
+61CC 9152
+61CD 73E0
+61CE 7587
+61CF 851F
+61D0 7C4C
+61D1 7D02
+61D2 7D2C
+61D3 7DA2
+61D4 8098
+61D5 80C4
+61D6 821F
+61D7 86DB
+61D8 8A3B
+61D9 8A85
+61DA 8D70
+61DB 8E8A
+61DC 8F33
+61DD 914E
+61DE 9031
+61DF 9444
+61E0 99D0
+61E1 7AF9
+61E2 7CA5
+61E3 4FCA
+61E4 5101
+61E5 51C6
+61E6 57C8
+61E7 5CFB
+61E8 6659
+61E9 6A3D
+61EA 6D5A
+61EB 6E96
+61EC 6FEC
+61ED 756F
+61EE 7AE3
+61EF 8822
+61F0 9021
+61F1 9075
+61F2 96BC
+61F3 99FF
+61F4 8301
+61F5 4E2D
+61F6 4EF2
+61F7 8846
+61F8 91CD
+61F9 F864
+61FA 537D
+61FB 6ADB
+61FC 696B
+61FD 6C41
+61FE 847A
+6241 589E
+6242 618E
+6243 62EF
+6244 70DD
+6245 66FE
+6246 7511
+6247 75C7
+6248 84B8
+6249 8A3C
+624A 8B49
+624B 8D08
+624C 4E4B
+624D 53EA
+624E 54AB
+624F 5730
+6250 5740
+6251 5FD7
+6252 6301
+6253 6307
+6254 646F
+6255 652F
+6256 65E8
+6257 667A
+6258 679D
+6259 67B3
+625A 6B62
+625B 6C60
+625C 6F2C
+625D 75E3
+625E 77E5
+625F 7825
+6260 7957
+6261 7949
+6262 7D19
+6263 80A2
+6264 8102
+6265 81F3
+6266 829D
+6267 8718
+6268 8A8C
+6269 F9FC
+626A 8D04
+626B 8DBE
+626C 9072
+626D 76F4
+626E 7A19
+626F 7A37
+6270 7E54
+6271 8077
+6272 8FB0
+6273 55D4
+6274 5875
+6275 632F
+6276 6649
+6277 699B
+6278 6D25
+6279 6EB1
+627A 73CD
+627B 7468
+627C 74A1
+627D 75B9
+627E 76E1
+627F 771E
+6280 778B
+6281 79E6
+6282 7E09
+6283 8A3A
+6284 8CD1
+6285 8EEB
+6286 9032
+6287 93AD
+6288 9663
+6289 9673
+628A 9707
+628B 53F1
+628C 7A92
+628D 59EA
+628E 5AC9
+628F 5E19
+6290 684E
+6291 75BE
+6292 79E9
+6293 81A3
+6294 86ED
+6295 8CEA
+6296 8DCC
+6297 8FED
+6298 659F
+6299 6715
+629A 57F7
+629B 96C6
+629C 7DDD
+629D 8F2F
+629E 5FB5
+629F 61F2
+62A0 6F84
+62A1 4E14
+62A2 501F
+62A3 7B9A
+62A4 53C9
+62A5 55DF
+62A6 5DEE
+62A7 5D6F
+62A8 6B21
+62A9 6B64
+62AA 78CB
+62AB F9FE
+62AC 8E49
+62AD 906E
+62AE 8ECA
+62AF 6349
+62B0 643E
+62B1 7740
+62B2 7A84
+62B3 932F
+62B4 947F
+62B5 9F6A
+62B6 64B0
+62B7 6FAF
+62B8 71E6
+62B9 74A8
+62BA 74DA
+62BB 7AC4
+62BC 7E82
+62BD 7CB2
+62BE 7E98
+62BF 8B9A
+62C0 8D0A
+62C1 947D
+62C2 F865
+62C3 9910
+62C4 994C
+62C5 5239
+62C6 5BDF
+62C7 64E6
+62C8 672D
+62C9 50ED
+62CA 53C3
+62CB 5879
+62CC 6158
+62CD 6159
+62CE 615A
+62CF 61FA
+62D0 65AC
+62D1 7AD9
+62D2 8B92
+62D3 5021
+62D4 5009
+62D5 5231
+62D6 5275
+62D7 5531
+62D8 5A3C
+62D9 5EE0
+62DA 5F70
+62DB 60B5
+62DC 655E
+62DD 660C
+62DE 6636
+62DF 66A2
+62E0 69CD
+62E1 6C05
+62E2 6EC4
+62E3 6F32
+62E4 7621
+62E5 7A93
+62E6 8139
+62E7 8259
+62E8 83D6
+62E9 84BC
+62EA 50B5
+62EB 57F0
+62EC 5F69
+62ED 63A1
+62EE 7826
+62EF 7DB5
+62F0 83DC
+62F1 8521
+62F2 91C7
+62F3 91F5
+62F4 518A
+62F5 67F5
+62F6 7B56
+62F7 7C00
+62F8 8CAC
+62F9 51C4
+62FA 59BB
+62FB 60BD
+62FC 8655
+62FD F9FF
+62FE 5254
+6341 5C3A
+6342 617D
+6343 621A
+6344 62D3
+6345 64F2
+6346 65A5
+6347 6ECC
+6348 7620
+6349 810A
+634A 8734
+634B 8E91
+634C 965F
+634D 96BB
+634E 4EDF
+634F 5343
+6350 5598
+6351 5929
+6352 5DDD
+6353 64C5
+6354 6CC9
+6355 6DFA
+6356 6FFA
+6357 7A7F
+6358 821B
+6359 85A6
+635A 8CE4
+635B 8E10
+635C 9077
+635D 91E7
+635E 95E1
+635F 9621
+6360 97C6
+6361 51F8
+6362 5FB9
+6363 54F2
+6364 5586
+6365 64A4
+6366 6F88
+6367 7DB4
+6368 8F4D
+6369 9435
+636A 50C9
+636B 5C16
+636C 6CBE
+636D 6DFB
+636E 751B
+636F 77BB
+6370 7C37
+6371 7C64
+6372 8AC2
+6373 59BE
+6374 5E16
+6375 6377
+6376 7252
+6377 758A
+6378 776B
+6379 8ADC
+637A 8CBC
+637B 8F12
+637C 5EF3
+637D 6674
+637E 6DF8
+637F 807D
+6380 83C1
+6381 873B
+6382 8ACB
+6383 9751
+6384 9BD6
+6385 FA00
+6386 5243
+6387 66FF
+6388 6D95
+6389 6EEF
+638A 780C
+638B 7DE0
+638C 8AE6
+638D 902E
+638E 905E
+638F 9746
+6390 9AD4
+6391 521D
+6392 54E8
+6393 5CED
+6394 6194
+6395 6284
+6396 62DB
+6397 68A2
+6398 6912
+6399 695A
+639A 6A35
+639B 7092
+639C 7126
+639D 785D
+639E 7901
+639F 790E
+63A0 79D2
+63A1 7A0D
+63A2 7D83
+63A3 8096
+63A4 8349
+63A5 8549
+63A6 8C82
+63A7 8D85
+63A8 9162
+63A9 918B
+63AA 91AE
+63AB 9214
+63AC 9798
+63AD 4FC3
+63AE 56D1
+63AF F866
+63B0 71ED
+63B1 77D7
+63B2 8700
+63B3 89F8
+63B4 8E85
+63B5 9AD1
+63B6 5BF8
+63B7 5FD6
+63B8 6751
+63B9 53E2
+63BA 585A
+63BB 5BF5
+63BC 6031
+63BD 6460
+63BE 7E3D
+63BF 8070
+63C0 8471
+63C1 9283
+63C2 64AE
+63C3 50AC
+63C4 5D14
+63C5 6467
+63C6 6700
+63C7 589C
+63C8 62BD
+63C9 63A8
+63CA 690E
+63CB 6978
+63CC F867
+63CD 6A1E
+63CE 6E6B
+63CF 7503
+63D0 76BA
+63D1 79CB
+63D2 7B92
+63D3 82BB
+63D4 8429
+63D5 8DA8
+63D6 8FFD
+63D7 9112
+63D8 914B
+63D9 919C
+63DA 9318
+63DB 9310
+63DC 96DB
+63DD 97A6
+63DE 9C0D
+63DF 9E81
+63E0 9EA4
+63E1 4E11
+63E2 F868
+63E3 795D
+63E4 755C
+63E5 7AFA
+63E6 7B51
+63E7 7BC9
+63E8 7E2E
+63E9 8233
+63EA 84C4
+63EB 8E74
+63EC 8EF8
+63ED 9010
+63EE 6625
+63EF 693F
+63F0 51FA
+63F1 9EDC
+63F2 5145
+63F3 51B2
+63F4 5FE0
+63F5 6C96
+63F6 87F2
+63F7 885D
+63F8 8877
+63F9 60B4
+63FA 81B5
+63FB 8403
+63FC 53D6
+63FD 5439
+63FE 5634
+6441 5A36
+6442 5C31
+6443 6A47
+6444 708A
+6445 7FE0
+6446 805A
+6447 8106
+6448 81ED
+6449 F869
+644A 8DA3
+644B 9189
+644C 9A5F
+644D 9DF2
+644E 4EC4
+644F 5074
+6450 60FB
+6451 6E2C
+6452 5C64
+6453 4F88
+6454 5024
+6455 55E4
+6456 5CD9
+6457 5DF5
+6458 5E5F
+6459 5FB4
+645A 6894
+645B 6CBB
+645C 6DC4
+645D 71BE
+645E 75D4
+645F 75F4
+6460 7661
+6461 96C9
+6462 7A1A
+6463 7DC7
+6464 7DFB
+6465 7F6E
+6466 6065
+6467 81F4
+6468 8F1C
+6469 99B3
+646A 9D44
+646B 9F52
+646C 5247
+646D 52C5
+646E 98ED
+646F 89AA
+6470 4E03
+6471 67D2
+6472 6F06
+6473 4FB5
+6474 5BE2
+6475 5FF1
+6476 6795
+6477 6C88
+6478 6D78
+6479 7827
+647A 91DD
+647B 937C
+647C 87C4
+647D 79E4
+647E 7A31
+647F 5FEB
+6480 4ED6
+6481 553E
+6482 58AE
+6483 59A5
+6484 60F0
+6485 6253
+6486 6736
+6487 6955
+6488 8235
+6489 9640
+648A 99DD
+648B 502C
+648C 5353
+648D 5544
+648E FA01
+648F 6258
+6490 62C6
+6491 FA02
+6492 64E2
+6493 67DD
+6494 6A50
+6495 6FC1
+6496 6FEF
+6497 7422
+6498 8A17
+6499 9438
+649A 5451
+649B 5606
+649C 5766
+649D 5F48
+649E 619A
+649F 6B4E
+64A0 7058
+64A1 70AD
+64A2 7DBB
+64A3 8A95
+64A4 596A
+64A5 812B
+64A6 63A2
+64A7 803D
+64A8 8CAA
+64A9 5854
+64AA 642D
+64AB 69BB
+64AC 5B95
+64AD 5E11
+64AE 6E6F
+64AF 8569
+64B0 514C
+64B1 53F0
+64B2 592A
+64B3 6020
+64B4 614B
+64B5 6B86
+64B6 6C70
+64B7 6CF0
+64B8 7B1E
+64B9 80CE
+64BA 82D4
+64BB 8DC6
+64BC 90B0
+64BD 98B1
+64BE 99C4
+64BF FA04
+64C0 64C7
+64C1 6FA4
+64C2 F86A
+64C3 6491
+64C4 6504
+64C5 514E
+64C6 5410
+64C7 571F
+64C8 8A0E
+64C9 615F
+64CA 6876
+64CB FA05
+64CC 75DB
+64CD 7B52
+64CE 7D71
+64CF 901A
+64D0 5806
+64D1 817F
+64D2 892A
+64D3 9000
+64D4 9839
+64D5 5078
+64D6 5957
+64D7 59AC
+64D8 6295
+64D9 900F
+64DA 9B2A
+64DB 615D
+64DC 7279
+64DD 5A46
+64DE 5761
+64DF 5DF4
+64E0 628A
+64E1 64AD
+64E2 6777
+64E3 6CE2
+64E4 6D3E
+64E5 722C
+64E6 7436
+64E7 7834
+64E8 7F77
+64E9 82AD
+64EA 8DDB
+64EB 9817
+64EC 5742
+64ED 5224
+64EE 677F
+64EF 7248
+64F0 8CA9
+64F1 8FA6
+64F2 74E3
+64F3 962A
+64F4 516B
+64F5 53ED
+64F6 634C
+64F7 4F69
+64F8 5504
+64F9 6096
+64FA 6C9B
+64FB 6D7F
+64FC 724C
+64FD 72FD
+64FE 7A17
+6541 8C9D
+6542 6557
+6543 8987
+6544 5F6D
+6545 6F8E
+6546 70F9
+6547 81A8
+6548 610E
+6549 4FBF
+654A 504F
+654B 6241
+654C 7247
+654D 7BC7
+654E 7DE8
+654F 7FE9
+6550 8759
+6551 904D
+6552 97AD
+6553 8CB6
+6554 576A
+6555 5E73
+6556 840D
+6557 8A55
+6558 5420
+6559 5B16
+655A 5E63
+655B 5EE2
+655C 5F0A
+655D 6583
+655E 80BA
+655F 853D
+6560 9589
+6561 965B
+6562 4F48
+6563 5305
+6564 530D
+6565 530F
+6566 5486
+6567 54FA
+6568 5703
+6569 5E96
+656A 5E03
+656B 6016
+656C 62B1
+656D 629B
+656E 6355
+656F 6CE1
+6570 6D66
+6571 70AE
+6572 75B1
+6573 7832
+6574 80DE
+6575 812F
+6576 8216
+6577 8461
+6578 84B2
+6579 888D
+657A 8912
+657B 924B
+657C 92EA
+657D 9784
+657E 98FD
+657F 9B91
+6580 5E45
+6581 66B4
+6582 7011
+6583 7206
+6584 4FF5
+6585 527D
+6586 5F6A
+6587 6153
+6588 6753
+6589 6A19
+658A 6F02
+658B 74E2
+658C 7968
+658D 8868
+658E 8C79
+658F 98C4
+6590 F86B
+6591 54C1
+6592 7A1F
+6593 99AE
+6594 6953
+6595 8AF7
+6596 8C4A
+6597 98A8
+6598 5F7C
+6599 62AB
+659A 75B2
+659B 76AE
+659C 84D6
+659D 88AB
+659E 907F
+659F 5339
+65A0 5F3C
+65A1 5FC5
+65A2 6CCC
+65A3 7562
+65A4 758B
+65A5 7B46
+65A6 8E55
+65A7 4E4F
+65A8 903C
+65A9 4E0B
+65AA 4F55
+65AB 590F
+65AC 5EC8
+65AD 6630
+65AE 6CB3
+65AF 7455
+65B0 8766
+65B1 8377
+65B2 8CC0
+65B3 9050
+65B4 971E
+65B5 9C15
+65B6 58D1
+65B7 5B78
+65B8 7627
+65B9 8650
+65BA 8B14
+65BB 9DB4
+65BC 5BD2
+65BD 6068
+65BE 608D
+65BF 65F1
+65C0 6C57
+65C1 6F22
+65C2 6FA3
+65C3 7F55
+65C4 7FF0
+65C5 F86C
+65C6 9592
+65C7 9591
+65C8 9650
+65C9 97D3
+65CA 9DF3
+65CB 5272
+65CC 8F44
+65CD 51FD
+65CE 542B
+65CF 54B8
+65D0 5563
+65D1 558A
+65D2 6ABB
+65D3 6DB5
+65D4 7DD8
+65D5 8266
+65D6 9677
+65D7 5408
+65D8 54C8
+65D9 76D2
+65DA 86E4
+65DB 95A4
+65DC 965C
+65DD 4EA2
+65DE 4F09
+65DF 59EE
+65E0 5DF7
+65E1 6052
+65E2 6297
+65E3 676D
+65E4 6841
+65E5 6C86
+65E6 6E2F
+65E7 7095
+65E8 7F38
+65E9 809B
+65EA 822A
+65EB FA09
+65EC 9805
+65ED 4EA5
+65EE 5055
+65EF 54B3
+65F0 595A
+65F1 5793
+65F2 5B69
+65F3 5BB3
+65F4 5EE8
+65F5 61C8
+65F6 6977
+65F7 6D77
+65F8 87F9
+65F9 89E3
+65FA 8A72
+65FB 8AE7
+65FC 9082
+65FD 99ED
+65FE 9AB8
+6641 52BE
+6642 6838
+6643 5016
+6644 5E78
+6645 674F
+6646 884C
+6647 4EAB
+6648 5411
+6649 56AE
+664A 9115
+664B 73E6
+664C 97FF
+664D 9909
+664E 9957
+664F 9999
+6650 5653
+6651 589F
+6652 865B
+6653 8A31
+6654 61B2
+6655 8ED2
+6656 737B
+6657 6B47
+6658 96AA
+6659 9A57
+665A 5955
+665B 7200
+665C 8D6B
+665D 9769
+665E 5CF4
+665F 5F26
+6660 61F8
+6661 70AB
+6662 73FE
+6663 7384
+6664 7729
+6665 7D43
+6666 7D62
+6667 7E23
+6668 8237
+6669 8852
+666A FA0A
+666B 8CE2
+666C 9249
+666D 986F
+666E 5B51
+666F 7A74
+6670 8840
+6671 9801
+6672 5ACC
+6673 F86D
+6674 4FE0
+6675 5354
+6676 593E
+6677 5CFD
+6678 633E
+6679 6D79
+667A 72F9
+667B 7BCB
+667C 8107
+667D 8105
+667E 83A2
+667F F86E
+6680 92CF
+6681 9830
+6682 4EA8
+6683 5211
+6684 578B
+6685 5F62
+6686 5144
+6687 7005
+6688 70AF
+6689 73E9
+668A 834A
+668B 87A2
+668C 8861
+668D 90A2
+668E 93A3
+668F 99A8
+6690 516E
+6691 5F57
+6692 60E0
+6693 6167
+6694 8559
+6695 91AF
+6696 978B
+6697 4E4E
+6698 4E92
+6699 8C6A
+669A 547C
+669B 58FA
+669C 58D5
+669D 597D
+669E 5F27
+669F 660A
+66A0 6236
+66A1 6BEB
+66A2 6D69
+66A3 6DCF
+66A4 6E56
+66A5 6EF8
+66A6 6F94
+66A7 6FE9
+66A8 6FE0
+66A9 705D
+66AA 72D0
+66AB 745A
+66AC 74E0
+66AD 7693
+66AE 769E
+66AF 795C
+66B0 7CCA
+66B1 7E1E
+66B2 80E1
+66B3 846B
+66B4 864E
+66B5 865F
+66B6 8774
+66B7 8B77
+66B8 6248
+66B9 9190
+66BA 93AC
+66BB 9800
+66BC 9865
+66BD 60D1
+66BE 6216
+66BF 9177
+66C0 5A5A
+66C1 660F
+66C2 6DF7
+66C3 6E3E
+66C4 743F
+66C5 9B42
+66C6 5FFD
+66C7 60DA
+66C8 7B0F
+66C9 9DBB
+66CA 5F18
+66CB 54C4
+66CC 6C5E
+66CD 6CD3
+66CE 6D2A
+66CF 9D3B
+66D0 7D05
+66D1 8679
+66D2 8A0C
+66D3 5316
+66D4 5B05
+66D5 6A3A
+66D6 706B
+66D7 798D
+66D8 7575
+66D9 79BE
+66DA 548C
+66DB 82B1
+66DC 83EF
+66DD 8A71
+66DE 9774
+66DF 8CA8
+66E0 FA0B
+66E1 64F4
+66E2 652B
+66E3 78BA
+66E4 78BB
+66E5 7A6B
+66E6 944A
+66E7 4E38
+66E8 559A
+66E9 571C
+66EA 5BA6
+66EB 5E7B
+66EC 60A3
+66ED 61FD
+66EE 63DB
+66EF 6853
+66F0 6B61
+66F1 6E19
+66F2 7165
+66F3 74B0
+66F4 7D08
+66F5 9084
+66F6 9A69
+66F7 9C25
+66F8 9B1F
+66F9 6D3B
+66FA 6ED1
+66FB 733E
+66FC 8C41
+66FD 95CA
+66FE 51F0
+6741 5A93
+6742 5FA8
+6743 6033
+6744 604D
+6745 614C
+6746 60F6
+6747 6643
+6748 6CC1
+6749 6EC9
+674A 714C
+674B 7687
+674C 7BC1
+674D 8352
+674E 8757
+674F 9051
+6750 968D
+6751 9EC3
+6752 56DE
+6753 5EFB
+6754 5F8A
+6755 6062
+6756 6094
+6757 61F7
+6758 6666
+6759 6703
+675A 6A9C
+675B 6DEE
+675C 6FAE
+675D 7070
+675E 736A
+675F 7E6A
+6760 81BE
+6761 86D4
+6762 8AA8
+6763 8CC4
+6764 5283
+6765 7372
+6766 6A6B
+6767 54EE
+6768 5686
+6769 56C2
+676A 5B5D
+676B 6548
+676C 66C9
+676D 689F
+676E 723B
+676F 80B4
+6770 9175
+6771 4FAF
+6772 5019
+6773 539A
+6774 540E
+6775 543C
+6776 5589
+6777 55C5
+6778 5F8C
+6779 673D
+677A 7334
+677B 9005
+677C 7BCC
+677D 52F3
+677E 5864
+677F 58CE
+6780 6688
+6781 7104
+6782 718F
+6783 71FB
+6784 85B0
+6785 8A13
+6786 85A8
+6787 55A7
+6788 8431
+6789 5349
+678A 5599
+678B 6BC1
+678C 5F59
+678D 5FBD
+678E 63EE
+678F 6689
+6790 7147
+6791 8AF1
+6792 8F1D
+6793 9EBE
+6794 4F11
+6795 643A
+6796 70CB
+6797 7566
+6798 8667
+6799 6064
+679A 8B4E
+679B 9DF8
+679C 51F6
+679D 5308
+679E 5147
+679F 6D36
+67A0 80F8
+67A1 9ED1
+67A2 5FFB
+67A3 6615
+67A4 6B23
+67A5 75D5
+67A6 5403
+67A7 5C79
+67A8 7D07
+67A9 8FC4
+67AA 6B20
+67AB 6B46
+67AC 6B3D
+67AD 5438
+67AE 6070
+67AF 6D3D
+67B0 8208
+67B1 50D6
+67B2 559C
+67B3 566B
+67B4 59EC
+67B5 5B09
+67B6 5E0C
+67B7 66E6
+67B8 6199
+67B9 6231
+67BA 72A7
+67BB 7199
+67BC 51DE
+67BD 71B9
+67BE 79A7
+67BF 7A00
+67C0 7FB2
+67C1 8A70
+67C2 9821
+6841 67B7
+6842 73C2
+6843 75C2
+6844 6164
+6845 4F83
+6846 67EC
+6847 687F
+6848 78F5
+6849 874E
+684A 6221
+684B 77B0
+684C 90AF
+684D 9452
+684E 5808
+684F 757A
+6850 7D73
+6851 7F8C
+6852 8221
+6853 9C47
+6854 584F
+6855 F900
+6856 93A7
+6857 5580
+6858 5028
+6859 795B
+685A 8E1E
+685B 9245
+685C 6957
+685D 8171
+685E 6840
+685F 5292
+6860 9210
+6861 8FF2
+6862 8188
+6863 6289
+6864 9257
+6865 4FD3
+6866 501E
+6867 5106
+6868 5770
+6869 61AC
+686A 70F1
+686B 74A5
+686C 583A
+686D 68E8
+686E 5C3B
+686F 66A0
+6870 69C1
+6871 7F94
+6872 82FD
+6873 83F0
+6874 7428
+6875 9BE4
+6876 73D9
+6877 86A3
+6878 978F
+6879 4E32
+687A 8DE8
+687B 934B
+687C 742F
+687D 4F8A
+687E 709A
+687F 5775
+6880 8009
+6881 92B6
+6882 97AB
+6883 88D9
+6884 828E
+6885 6372
+6886 6DC3
+6887 7357
+6888 8568
+6889 F906
+688A 6677
+688B 69FB
+688C 7AC5
+688D 52FB
+688E 7547
+688F 52A4
+6890 5997
+6891 6611
+6892 82A9
+6893 4F0B
+6894 57FC
+6895 7398
+6896 7482
+6897 7941
+6898 7F88
+6899 9324
+689A F90B
+689B F90C
+689C 5A1C
+689D F90D
+689E F90E
+689F F90F
+68A0 F910
+68A1 F911
+68A2 F912
+68A3 F913
+68A4 F914
+68A5 F915
+68A6 F916
+68A7 F917
+68A8 F918
+68A9 F919
+68AA F91A
+68AB F91B
+68AC F91C
+68AD F91D
+68AE F91E
+68AF F91F
+68B0 F920
+68B1 F921
+68B2 678F
+68B3 6960
+68B4 6E73
+68B5 F922
+68B6 F923
+68B7 F924
+68B8 F925
+68B9 F926
+68BA F927
+68BB 8872
+68BC F928
+68BD F929
+68BE F92A
+68BF F92B
+68C0 F92C
+68C1 F92D
+68C2 F92E
+68C3 649A
+68C4 5BD7
+68C5 F92F
+68C6 F930
+68C7 F931
+68C8 F932
+68C9 F933
+68CA F934
+68CB F935
+68CC F936
+68CD F937
+68CE F938
+68CF 99D1
+68D0 F939
+68D1 F93A
+68D2 F93B
+68D3 F93C
+68D4 F93D
+68D5 F93E
+68D6 F93F
+68D7 F940
+68D8 F941
+68D9 F942
+68DA F943
+68DB F944
+68DC F945
+68DD F946
+68DE F947
+68DF F948
+68E0 F949
+68E1 F94A
+68E2 F94B
+68E3 F94C
+68E4 F94D
+68E5 F94E
+68E6 F94F
+68E7 F950
+68E8 F951
+68E9 677B
+68EA F952
+68EB F953
+68EC F954
+68ED F955
+68EE F956
+68EF F957
+68F0 F958
+68F1 F959
+68F2 4EB6
+68F3 5F56
+68F4 6FBE
+68F5 574D
+68F6 61BA
+68F7 6E5B
+68F8 8541
+68F9 931F
+68FA 7553
+68FB 6207
+68FC 87B3
+68FD 576E
+68FE 5D8B
+6941 6389
+6942 6AC2
+6943 89A9
+6944 65FD
+6945 711E
+6946 9017
+6947 829A
+6948 5D9D
+6949 F95B
+694A F95D
+694B F95E
+694C 5D0D
+694D 5FA0
+694E 5137
+694F 7489
+6950 F95F
+6951 5CBA
+6952 7B2D
+6953 8046
+6954 6FA7
+6955 F960
+6956 64C4
+6957 6F5E
+6958 797F
+6959 83C9
+695A 7028
+695B 8CDA
+695C 9B27
+695D 5A41
+695E 763B
+695F 851E
+6960 93E4
+6961 65D2
+6962 700F
+6963 4F96
+6964 51DC
+6965 550E
+6966 6D6C
+6967 F962
+6968 7FB8
+6969 8389
+696A 88E1
+696B 6F7E
+696C 78BC
+696D 9088
+696E 4E07
+696F 534D
+6970 551C
+6971 8309
+6972 8F1E
+6973 6C94
+6974 6927
+6975 7791
+6976 84C2
+6977 6479
+6978 7441
+6979 82BC
+697A 9DA9
+697B 7AD7
+697C 61AE
+697D 6959
+697E 73F7
+697F 5011
+6980 96EF
+6981 6C95
+6982 68B6
+6983 6963
+6984 6E44
+6985 9EF4
+6986 5CB7
+6987 7DE1
+6988 7622
+6989 76FC
+698A 78D0
+698B 6E24
+698C 678B
+698D 6EC2
+698E 78C5
+698F 7119
+6990 5E61
+6991 71D4
+6992 6A97
+6993 8617
+6994 68C5
+6995 9A08
+6996 73E4
+6997 83E9
+6998 8F39
+6999 71A2
+699A 4E0D
+699B 4FEF
+699C 5490
+699D 5B5A
+699E 8240
+699F 83A9
+69A0 5429
+69A1 6610
+69A2 8CC1
+69A3 5F7F
+69A4 6787
+69A5 6BD6
+69A6 6BD7
+69A7 79D5
+69A8 7C83
+69A9 56AC
+69AA 6D5C
+69AB 73AD
+69AC 4FDF
+69AD 67F6
+69AE 9E9D
+69AF 9730
+69B0 715E
+69B1 9212
+69B2 5CE0
+69B3 55C7
+69B4 637F
+69B5 7B6E
+69B6 5B0B
+69B7 657E
+69B8 6E32
+69B9 7401
+69BA 9425
+69BB 994D
+69BC 6CC4
+69BD 893B
+69BE 9F67
+69BF 5261
+69C0 965D
+69C1 5BAC
+69C2 73F9
+69C3 7619
+69C4 7BE0
+69C5 6D91
+69C6 8B16
+69C7 8D16
+69C8 5DFD
+69C9 84C0
+69CA 98E1
+69CB 609A
+69CC 6DDE
+69CD 5CC0
+69CE 7407
+69CF 74B2
+69D0 8B90
+69D1 96A7
+69D2 6F5A
+69D3 7421
+69D4 74B9
+69D5 5F87
+69D6 6812
+69D7 6A53
+69D8 84F4
+69D9 8563
+69DA 8AC4
+69DB 9265
+69DC 5C4E
+69DD 8C55
+69DE 7BD2
+69DF 8755
+69E0 4F81
+69E1 85CE
+69E2 8AF6
+69E3 555E
+69E4 83AA
+69E5 5E44
+69E6 9102
+69E7 9354
+69E8 9C10
+69E9 9B9F
+69EA 5535
+69EB 5CA9
+69EC 627C
+69ED 7E0A
+69EE F975
+69EF F976
+69F0 84BB
+69F1 F977
+69F2 F978
+69F3 F979
+69F4 F97A
+69F5 79B3
+69F6 F97B
+69F7 F97C
+69F8 F97D
+69F9 F97E
+69FA 7600
+69FB 8616
+69FC 4FFA
+69FD 5186
+69FE F97F
+6A41 F980
+6A42 F981
+6A43 F982
+6A44 F983
+6A45 F984
+6A46 74B5
+6A47 7916
+6A48 F985
+6A49 8245
+6A4A 8339
+6A4B 8F3F
+6A4C 8F5D
+6A4D F986
+6A4E F987
+6A4F F988
+6A50 F989
+6A51 F98A
+6A52 F98B
+6A53 F98C
+6A54 F98D
+6A55 F98E
+6A56 F98F
+6A57 F990
+6A58 633B
+6A59 6C87
+6A5A F992
+6A5B F993
+6A5C F994
+6A5D F995
+6A5E F996
+6A5F 7E2F
+6A60 F997
+6A61 F998
+6A62 F999
+6A63 F99A
+6A64 F99B
+6A65 F99C
+6A66 F99D
+6A67 F99F
+6A68 F9A0
+6A69 F9A2
+6A6A F9A3
+6A6B F9A4
+6A6C F9A5
+6A6D 7430
+6A6E F9A6
+6A6F F9A7
+6A70 F9A8
+6A71 F9A9
+6A72 F9AA
+6A73 F9AB
+6A74 5DB8
+6A75 F9AC
+6A76 6E36
+6A77 6FDA
+6A78 702F
+6A79 7150
+6A7A 7370
+6A7B F9AD
+6A7C 7A4E
+6A7D F9AF
+6A7E F9B0
+6A7F F9B1
+6A80 9348
+6A81 F9B2
+6A82 9719
+6A83 F9B3
+6A84 F9B4
+6A85 4E42
+6A86 F9B5
+6A87 6C6D
+6A88 7A62
+6A89 F9B6
+6A8A F9B7
+6A8B F9B8
+6A8C 4FC9
+6A8D 5862
+6A8E 61CA
+6A8F 6556
+6A90 6FB3
+6A91 71AC
+6A92 7B7D
+6A93 9C32
+6A94 9F07
+6A95 7E15
+6A96 9954
+6A97 7AAA
+6A98 68A1
+6A99 6900
+6A9A 7413
+6A9B 8118
+6A9C 5A03
+6A9D 5D6C
+6A9E F9BA
+6A9F F9BB
+6AA0 5BE5
+6AA1 F9BC
+6AA2 F9BD
+6AA3 6493
+6AA4 F9BE
+6AA5 F9C0
+6AA6 71FF
+6AA7 F9C1
+6AA8 F9C2
+6AA9 F9C3
+6AAA 7E1F
+6AAB 4FD1
+6AAC 57C7
+6AAD 5889
+6AAE 6142
+6AAF 6D8C
+6AB0 752C
+6AB1 F9C4
+6AB2 65F4
+6AB3 7397
+6AB4 7440
+6AB5 7D06
+6AB6 85D5
+6AB7 91EA
+6AB8 52D6
+6AB9 5F67
+6ABA 682F
+6ABB 6A52
+6ABC 6F90
+6ABD 7189
+6ABE 8553
+6ABF 4E90
+6AC0 5AC4
+6AC1 6C85
+6AC2 6D39
+6AC3 6E72
+6AC4 F9C6
+6AC5 6690
+6AC6 853F
+6AC7 8918
+6AC8 F9C7
+6AC9 F9C8
+6ACA F9C9
+6ACB 6962
+6ACC 6D27
+6ACD F9CA
+6ACE F9CB
+6ACF 7337
+6AD0 F9CC
+6AD1 F9CD
+6AD2 F9CE
+6AD3 F9CF
+6AD4 F9D0
+6AD5 F9D1
+6AD6 5809
+6AD7 F9D2
+6AD8 F9D3
+6AD9 F9D4
+6ADA F9D5
+6ADB F9D6
+6ADC 8D07
+6ADD F9D7
+6ADE 9217
+6ADF F9D8
+6AE0 F9D9
+6AE1 F9DA
+6AE2 F9DB
+6AE3 701C
+6AE4 F9DC
+6AE5 6905
+6AE6 858F
+6AE7 F9DD
+6AE8 F9DE
+6AE9 F9DF
+6AEA F9E1
+6AEB F9E2
+6AEC F9E3
+6AED F9E4
+6AEE F9E5
+6AEF F9E6
+6AF0 8084
+6AF1 82E1
+6AF2 F9E7
+6AF3 F9E8
+6AF4 8CBD
+6AF5 9087
+6AF6 F9E9
+6AF7 F9EA
+6AF8 F9EB
+6AF9 F9EC
+6AFA 8B1A
+6AFB F9ED
+6AFC F9EE
+6AFD F9EF
+6AFE 7D6A
+6B41 8335
+6B42 F9F0
+6B43 8693
+6B44 F9F1
+6B45 F9F2
+6B46 F9F3
+6B47 4F5A
+6B48 6041
+6B49 F9F4
+6B4A F9F5
+6B4B F9F6
+6B4C 5344
+6B4D F9F7
+6B4E F9F8
+6B4F F9F9
+6B50 82BF
+6B51 8328
+6B52 5B71
+6B53 81E7
+6B54 6E3D
+6B55 7E21
+6B56 7D35
+6B57 83F9
+6B58 96CE
+6B59 9F5F
+6B5A 540A
+6B5B F9FB
+6B5C 7FDF
+6B5D 93D1
+6B5E 4F43
+6B5F 4F7A
+6B60 587C
+6B61 7420
+6B62 7551
+6B63 7B4C
+6B64 942B
+6B65 7664
+6B66 9B8E
+6B67 67FE
+6B68 6A89
+6B69 6DC0
+6B6A 6E5E
+6B6B 701E
+6B6C 70A1
+6B6D 738E
+6B6E 73FD
+6B6F 7D8E
+6B70 92CC
+6B71 74AA
+6B72 96D5
+6B73 60B0
+6B74 8E2A
+6B75 59DD
+6B76 6E4A
+6B77 6F8D
+6B78 5BEF
+6B79 710C
+6B7A 96CB
+6B7B 7E52
+6B7C 6C9A
+6B7D 82B7
+6B7E 5507
+6B7F 6422
+6B80 664B
+6B81 686D
+6B82 6B84
+6B83 755B
+6B84 7E1D
+6B85 81FB
+6B86 852F
+6B87 8897
+6B88 4F84
+6B89 74C6
+6B8A F9FD
+6B8B 6F57
+6B8C 93F6
+6B8D 4F98
+6B8E 7C12
+6B8F 7D2E
+6B90 8B96
+6B91 6134
+6B92 7316
+6B93 5BC0
+6B94 5BE8
+6B95 501C
+6B96 8E60
+6B97 7394
+6B98 8F1F
+6B99 7C3D
+6B9A 8A79
+6B9B 581E
+6B9C 527F
+6B9D 8278
+6B9E 82D5
+6B9F 90A8
+6BA0 60A4
+6BA1 6181
+6BA2 8525
+6BA3 8ACF
+6BA4 939A
+6BA5 9A36
+6BA6 8E59
+6BA7 7443
+6BA8 672E
+6BA9 8D05
+6BAA 53A0
+6BAB 7A49
+6BAC 86A9
+6BAD 741B
+6BAE 54A4
+6BAF 62D6
+6BB0 99B1
+6BB1 577C
+6BB2 666B
+6BB3 7438
+6BB4 7708
+6BB5 FA03
+6BB6 69CC
+6BB7 95D6
+6BB8 64FA
+6BB9 9211
+6BBA 9A19
+6BBB 67B0
+6BBC FA06
+6BBD 82DE
+6BBE 900B
+6BBF 66DD
+6BC0 FA07
+6BC1 98C7
+6BC2 9A43
+6BC3 9642
+6BC4 73CC
+6BC5 82FE
+6BC6 999D
+6BC7 53A6
+6BC8 701A
+6BC9 929C
+6BCA 9E79
+6BCB 95D4
+6BCC 5AE6
+6BCD FA08
+6BCE 7023
+6BCF 8347
+6BD0 6AF6
+6BD1 4FD4
+6BD2 774D
+6BD3 6CEB
+6BD4 73B9
+6BD5 665B
+6BD6 6CC2
+6BD7 6ECE
+6BD8 7050
+6BD9 7192
+6BDA 7469
+6BDB 9008
+6BDC 66B3
+6BDD 8E4A
+6BDE 5CB5
+6BDF 6667
+6BE0 7425
+6BE1 82A6
+6BE2 84BF
+6BE3 70D8
+6BE4 8B41
+6BE5 5950
+6BE6 6665
+6BE7 5E4C
+6BE8 6130
+6BE9 6644
+6BEA 69A5
+6BEB 6E5F
+6BEC 6F62
+6BED 749C
+6BEE 7C27
+6BEF 532F
+6BF0 8334
+6BF1 5B96
+6BF2 9404
+6BF3 6585
+6BF4 6D8D
+6BF5 6DC6
+6BF6 9A4D
+6BF7 5E3F
+6BF8 7166
+6BF9 73DD
+6BFA 52DB
+6BFB 6684
+6BFC 714A
+6BFD 7098
+6BFE 8A16
+6C41 7FD5
+6C42 56CD
+6C43 6198
+6C44 665E
+6C45 71BA
+8441 3164
+8444 3133
+8446 3135
+8447 3136
+844A 313A
+844B 313B
+844C 313C
+844D 313D
+844E 313E
+844F 313F
+8450 3140
+8454 3144
+8461 314F
+8481 3150
+84A1 3151
+84C1 3152
+84E1 3153
+8541 3154
+8561 3155
+8581 3156
+85A1 3157
+85C1 3158
+85E1 3159
+8641 315A
+8661 315B
+8681 315C
+86A1 315D
+86C1 315E
+86E1 315F
+8741 3160
+8761 3161
+8781 3162
+87A1 3163
+8841 3131
+8861 AC00
+8862 AC01
+8863 AC02
+8864 AC03
+8865 AC04
+8866 AC05
+8867 AC06
+8868 AC07
+8869 AC08
+886A AC09
+886B AC0A
+886C AC0B
+886D AC0C
+886E AC0D
+886F AC0E
+8870 AC0F
+8871 AC10
+8873 AC11
+8874 AC12
+8875 AC13
+8876 AC14
+8877 AC15
+8878 AC16
+8879 AC17
+887A AC18
+887B AC19
+887C AC1A
+887D AC1B
+8881 AC1C
+8882 AC1D
+8883 AC1E
+8884 AC1F
+8885 AC20
+8886 AC21
+8887 AC22
+8888 AC23
+8889 AC24
+888A AC25
+888B AC26
+888C AC27
+888D AC28
+888E AC29
+888F AC2A
+8890 AC2B
+8891 AC2C
+8893 AC2D
+8894 AC2E
+8895 AC2F
+8896 AC30
+8897 AC31
+8898 AC32
+8899 AC33
+889A AC34
+889B AC35
+889C AC36
+889D AC37
+88A1 AC38
+88A2 AC39
+88A3 AC3A
+88A4 AC3B
+88A5 AC3C
+88A6 AC3D
+88A7 AC3E
+88A8 AC3F
+88A9 AC40
+88AA AC41
+88AB AC42
+88AC AC43
+88AD AC44
+88AE AC45
+88AF AC46
+88B0 AC47
+88B1 AC48
+88B3 AC49
+88B4 AC4A
+88B5 AC4B
+88B6 AC4C
+88B7 AC4D
+88B8 AC4E
+88B9 AC4F
+88BA AC50
+88BB AC51
+88BC AC52
+88BD AC53
+88C1 AC54
+88C2 AC55
+88C3 AC56
+88C4 AC57
+88C5 AC58
+88C6 AC59
+88C7 AC5A
+88C8 AC5B
+88C9 AC5C
+88CA AC5D
+88CB AC5E
+88CC AC5F
+88CD AC60
+88CE AC61
+88CF AC62
+88D0 AC63
+88D1 AC64
+88D3 AC65
+88D4 AC66
+88D5 AC67
+88D6 AC68
+88D7 AC69
+88D8 AC6A
+88D9 AC6B
+88DA AC6C
+88DB AC6D
+88DC AC6E
+88DD AC6F
+88E1 AC70
+88E2 AC71
+88E3 AC72
+88E4 AC73
+88E5 AC74
+88E6 AC75
+88E7 AC76
+88E8 AC77
+88E9 AC78
+88EA AC79
+88EB AC7A
+88EC AC7B
+88ED AC7C
+88EE AC7D
+88EF AC7E
+88F0 AC7F
+88F1 AC80
+88F3 AC81
+88F4 AC82
+88F5 AC83
+88F6 AC84
+88F7 AC85
+88F8 AC86
+88F9 AC87
+88FA AC88
+88FB AC89
+88FC AC8A
+88FD AC8B
+8941 AC8C
+8942 AC8D
+8943 AC8E
+8944 AC8F
+8945 AC90
+8946 AC91
+8947 AC92
+8948 AC93
+8949 AC94
+894A AC95
+894B AC96
+894C AC97
+894D AC98
+894E AC99
+894F AC9A
+8950 AC9B
+8951 AC9C
+8953 AC9D
+8954 AC9E
+8955 AC9F
+8956 ACA0
+8957 ACA1
+8958 ACA2
+8959 ACA3
+895A ACA4
+895B ACA5
+895C ACA6
+895D ACA7
+8961 ACA8
+8962 ACA9
+8963 ACAA
+8964 ACAB
+8965 ACAC
+8966 ACAD
+8967 ACAE
+8968 ACAF
+8969 ACB0
+896A ACB1
+896B ACB2
+896C ACB3
+896D ACB4
+896E ACB5
+896F ACB6
+8970 ACB7
+8971 ACB8
+8973 ACB9
+8974 ACBA
+8975 ACBB
+8976 ACBC
+8977 ACBD
+8978 ACBE
+8979 ACBF
+897A ACC0
+897B ACC1
+897C ACC2
+897D ACC3
+8981 ACC4
+8982 ACC5
+8983 ACC6
+8984 ACC7
+8985 ACC8
+8986 ACC9
+8987 ACCA
+8988 ACCB
+8989 ACCC
+898A ACCD
+898B ACCE
+898C ACCF
+898D ACD0
+898E ACD1
+898F ACD2
+8990 ACD3
+8991 ACD4
+8993 ACD5
+8994 ACD6
+8995 ACD7
+8996 ACD8
+8997 ACD9
+8998 ACDA
+8999 ACDB
+899A ACDC
+899B ACDD
+899C ACDE
+899D ACDF
+89A1 ACE0
+89A2 ACE1
+89A3 ACE2
+89A4 ACE3
+89A5 ACE4
+89A6 ACE5
+89A7 ACE6
+89A8 ACE7
+89A9 ACE8
+89AA ACE9
+89AB ACEA
+89AC ACEB
+89AD ACEC
+89AE ACED
+89AF ACEE
+89B0 ACEF
+89B1 ACF0
+89B3 ACF1
+89B4 ACF2
+89B5 ACF3
+89B6 ACF4
+89B7 ACF5
+89B8 ACF6
+89B9 ACF7
+89BA ACF8
+89BB ACF9
+89BC ACFA
+89BD ACFB
+89C1 ACFC
+89C2 ACFD
+89C3 ACFE
+89C4 ACFF
+89C5 AD00
+89C6 AD01
+89C7 AD02
+89C8 AD03
+89C9 AD04
+89CA AD05
+89CB AD06
+89CC AD07
+89CD AD08
+89CE AD09
+89CF AD0A
+89D0 AD0B
+89D1 AD0C
+89D3 AD0D
+89D4 AD0E
+89D5 AD0F
+89D6 AD10
+89D7 AD11
+89D8 AD12
+89D9 AD13
+89DA AD14
+89DB AD15
+89DC AD16
+89DD AD17
+89E1 AD18
+89E2 AD19
+89E3 AD1A
+89E4 AD1B
+89E5 AD1C
+89E6 AD1D
+89E7 AD1E
+89E8 AD1F
+89E9 AD20
+89EA AD21
+89EB AD22
+89EC AD23
+89ED AD24
+89EE AD25
+89EF AD26
+89F0 AD27
+89F1 AD28
+89F3 AD29
+89F4 AD2A
+89F5 AD2B
+89F6 AD2C
+89F7 AD2D
+89F8 AD2E
+89F9 AD2F
+89FA AD30
+89FB AD31
+89FC AD32
+89FD AD33
+8A41 AD34
+8A42 AD35
+8A43 AD36
+8A44 AD37
+8A45 AD38
+8A46 AD39
+8A47 AD3A
+8A48 AD3B
+8A49 AD3C
+8A4A AD3D
+8A4B AD3E
+8A4C AD3F
+8A4D AD40
+8A4E AD41
+8A4F AD42
+8A50 AD43
+8A51 AD44
+8A53 AD45
+8A54 AD46
+8A55 AD47
+8A56 AD48
+8A57 AD49
+8A58 AD4A
+8A59 AD4B
+8A5A AD4C
+8A5B AD4D
+8A5C AD4E
+8A5D AD4F
+8A61 AD50
+8A62 AD51
+8A63 AD52
+8A64 AD53
+8A65 AD54
+8A66 AD55
+8A67 AD56
+8A68 AD57
+8A69 AD58
+8A6A AD59
+8A6B AD5A
+8A6C AD5B
+8A6D AD5C
+8A6E AD5D
+8A6F AD5E
+8A70 AD5F
+8A71 AD60
+8A73 AD61
+8A74 AD62
+8A75 AD63
+8A76 AD64
+8A77 AD65
+8A78 AD66
+8A79 AD67
+8A7A AD68
+8A7B AD69
+8A7C AD6A
+8A7D AD6B
+8A81 AD6C
+8A82 AD6D
+8A83 AD6E
+8A84 AD6F
+8A85 AD70
+8A86 AD71
+8A87 AD72
+8A88 AD73
+8A89 AD74
+8A8A AD75
+8A8B AD76
+8A8C AD77
+8A8D AD78
+8A8E AD79
+8A8F AD7A
+8A90 AD7B
+8A91 AD7C
+8A93 AD7D
+8A94 AD7E
+8A95 AD7F
+8A96 AD80
+8A97 AD81
+8A98 AD82
+8A99 AD83
+8A9A AD84
+8A9B AD85
+8A9C AD86
+8A9D AD87
+8AA1 AD88
+8AA2 AD89
+8AA3 AD8A
+8AA4 AD8B
+8AA5 AD8C
+8AA6 AD8D
+8AA7 AD8E
+8AA8 AD8F
+8AA9 AD90
+8AAA AD91
+8AAB AD92
+8AAC AD93
+8AAD AD94
+8AAE AD95
+8AAF AD96
+8AB0 AD97
+8AB1 AD98
+8AB3 AD99
+8AB4 AD9A
+8AB5 AD9B
+8AB6 AD9C
+8AB7 AD9D
+8AB8 AD9E
+8AB9 AD9F
+8ABA ADA0
+8ABB ADA1
+8ABC ADA2
+8ABD ADA3
+8AC1 ADA4
+8AC2 ADA5
+8AC3 ADA6
+8AC4 ADA7
+8AC5 ADA8
+8AC6 ADA9
+8AC7 ADAA
+8AC8 ADAB
+8AC9 ADAC
+8ACA ADAD
+8ACB ADAE
+8ACC ADAF
+8ACD ADB0
+8ACE ADB1
+8ACF ADB2
+8AD0 ADB3
+8AD1 ADB4
+8AD3 ADB5
+8AD4 ADB6
+8AD5 ADB7
+8AD6 ADB8
+8AD7 ADB9
+8AD8 ADBA
+8AD9 ADBB
+8ADA ADBC
+8ADB ADBD
+8ADC ADBE
+8ADD ADBF
+8AE1 ADC0
+8AE2 ADC1
+8AE3 ADC2
+8AE4 ADC3
+8AE5 ADC4
+8AE6 ADC5
+8AE7 ADC6
+8AE8 ADC7
+8AE9 ADC8
+8AEA ADC9
+8AEB ADCA
+8AEC ADCB
+8AED ADCC
+8AEE ADCD
+8AEF ADCE
+8AF0 ADCF
+8AF1 ADD0
+8AF3 ADD1
+8AF4 ADD2
+8AF5 ADD3
+8AF6 ADD4
+8AF7 ADD5
+8AF8 ADD6
+8AF9 ADD7
+8AFA ADD8
+8AFB ADD9
+8AFC ADDA
+8AFD ADDB
+8B41 ADDC
+8B42 ADDD
+8B43 ADDE
+8B44 ADDF
+8B45 ADE0
+8B46 ADE1
+8B47 ADE2
+8B48 ADE3
+8B49 ADE4
+8B4A ADE5
+8B4B ADE6
+8B4C ADE7
+8B4D ADE8
+8B4E ADE9
+8B4F ADEA
+8B50 ADEB
+8B51 ADEC
+8B53 ADED
+8B54 ADEE
+8B55 ADEF
+8B56 ADF0
+8B57 ADF1
+8B58 ADF2
+8B59 ADF3
+8B5A ADF4
+8B5B ADF5
+8B5C ADF6
+8B5D ADF7
+8B61 ADF8
+8B62 ADF9
+8B63 ADFA
+8B64 ADFB
+8B65 ADFC
+8B66 ADFD
+8B67 ADFE
+8B68 ADFF
+8B69 AE00
+8B6A AE01
+8B6B AE02
+8B6C AE03
+8B6D AE04
+8B6E AE05
+8B6F AE06
+8B70 AE07
+8B71 AE08
+8B73 AE09
+8B74 AE0A
+8B75 AE0B
+8B76 AE0C
+8B77 AE0D
+8B78 AE0E
+8B79 AE0F
+8B7A AE10
+8B7B AE11
+8B7C AE12
+8B7D AE13
+8B81 AE14
+8B82 AE15
+8B83 AE16
+8B84 AE17
+8B85 AE18
+8B86 AE19
+8B87 AE1A
+8B88 AE1B
+8B89 AE1C
+8B8A AE1D
+8B8B AE1E
+8B8C AE1F
+8B8D AE20
+8B8E AE21
+8B8F AE22
+8B90 AE23
+8B91 AE24
+8B93 AE25
+8B94 AE26
+8B95 AE27
+8B96 AE28
+8B97 AE29
+8B98 AE2A
+8B99 AE2B
+8B9A AE2C
+8B9B AE2D
+8B9C AE2E
+8B9D AE2F
+8BA1 AE30
+8BA2 AE31
+8BA3 AE32
+8BA4 AE33
+8BA5 AE34
+8BA6 AE35
+8BA7 AE36
+8BA8 AE37
+8BA9 AE38
+8BAA AE39
+8BAB AE3A
+8BAC AE3B
+8BAD AE3C
+8BAE AE3D
+8BAF AE3E
+8BB0 AE3F
+8BB1 AE40
+8BB3 AE41
+8BB4 AE42
+8BB5 AE43
+8BB6 AE44
+8BB7 AE45
+8BB8 AE46
+8BB9 AE47
+8BBA AE48
+8BBB AE49
+8BBC AE4A
+8BBD AE4B
+8C41 3132
+8C61 AE4C
+8C62 AE4D
+8C63 AE4E
+8C64 AE4F
+8C65 AE50
+8C66 AE51
+8C67 AE52
+8C68 AE53
+8C69 AE54
+8C6A AE55
+8C6B AE56
+8C6C AE57
+8C6D AE58
+8C6E AE59
+8C6F AE5A
+8C70 AE5B
+8C71 AE5C
+8C73 AE5D
+8C74 AE5E
+8C75 AE5F
+8C76 AE60
+8C77 AE61
+8C78 AE62
+8C79 AE63
+8C7A AE64
+8C7B AE65
+8C7C AE66
+8C7D AE67
+8C81 AE68
+8C82 AE69
+8C83 AE6A
+8C84 AE6B
+8C85 AE6C
+8C86 AE6D
+8C87 AE6E
+8C88 AE6F
+8C89 AE70
+8C8A AE71
+8C8B AE72
+8C8C AE73
+8C8D AE74
+8C8E AE75
+8C8F AE76
+8C90 AE77
+8C91 AE78
+8C93 AE79
+8C94 AE7A
+8C95 AE7B
+8C96 AE7C
+8C97 AE7D
+8C98 AE7E
+8C99 AE7F
+8C9A AE80
+8C9B AE81
+8C9C AE82
+8C9D AE83
+8CA1 AE84
+8CA2 AE85
+8CA3 AE86
+8CA4 AE87
+8CA5 AE88
+8CA6 AE89
+8CA7 AE8A
+8CA8 AE8B
+8CA9 AE8C
+8CAA AE8D
+8CAB AE8E
+8CAC AE8F
+8CAD AE90
+8CAE AE91
+8CAF AE92
+8CB0 AE93
+8CB1 AE94
+8CB3 AE95
+8CB4 AE96
+8CB5 AE97
+8CB6 AE98
+8CB7 AE99
+8CB8 AE9A
+8CB9 AE9B
+8CBA AE9C
+8CBB AE9D
+8CBC AE9E
+8CBD AE9F
+8CC1 AEA0
+8CC2 AEA1
+8CC3 AEA2
+8CC4 AEA3
+8CC5 AEA4
+8CC6 AEA5
+8CC7 AEA6
+8CC8 AEA7
+8CC9 AEA8
+8CCA AEA9
+8CCB AEAA
+8CCC AEAB
+8CCD AEAC
+8CCE AEAD
+8CCF AEAE
+8CD0 AEAF
+8CD1 AEB0
+8CD3 AEB1
+8CD4 AEB2
+8CD5 AEB3
+8CD6 AEB4
+8CD7 AEB5
+8CD8 AEB6
+8CD9 AEB7
+8CDA AEB8
+8CDB AEB9
+8CDC AEBA
+8CDD AEBB
+8CE1 AEBC
+8CE2 AEBD
+8CE3 AEBE
+8CE4 AEBF
+8CE5 AEC0
+8CE6 AEC1
+8CE7 AEC2
+8CE8 AEC3
+8CE9 AEC4
+8CEA AEC5
+8CEB AEC6
+8CEC AEC7
+8CED AEC8
+8CEE AEC9
+8CEF AECA
+8CF0 AECB
+8CF1 AECC
+8CF3 AECD
+8CF4 AECE
+8CF5 AECF
+8CF6 AED0
+8CF7 AED1
+8CF8 AED2
+8CF9 AED3
+8CFA AED4
+8CFB AED5
+8CFC AED6
+8CFD AED7
+8D41 AED8
+8D42 AED9
+8D43 AEDA
+8D44 AEDB
+8D45 AEDC
+8D46 AEDD
+8D47 AEDE
+8D48 AEDF
+8D49 AEE0
+8D4A AEE1
+8D4B AEE2
+8D4C AEE3
+8D4D AEE4
+8D4E AEE5
+8D4F AEE6
+8D50 AEE7
+8D51 AEE8
+8D53 AEE9
+8D54 AEEA
+8D55 AEEB
+8D56 AEEC
+8D57 AEED
+8D58 AEEE
+8D59 AEEF
+8D5A AEF0
+8D5B AEF1
+8D5C AEF2
+8D5D AEF3
+8D61 AEF4
+8D62 AEF5
+8D63 AEF6
+8D64 AEF7
+8D65 AEF8
+8D66 AEF9
+8D67 AEFA
+8D68 AEFB
+8D69 AEFC
+8D6A AEFD
+8D6B AEFE
+8D6C AEFF
+8D6D AF00
+8D6E AF01
+8D6F AF02
+8D70 AF03
+8D71 AF04
+8D73 AF05
+8D74 AF06
+8D75 AF07
+8D76 AF08
+8D77 AF09
+8D78 AF0A
+8D79 AF0B
+8D7A AF0C
+8D7B AF0D
+8D7C AF0E
+8D7D AF0F
+8D81 AF10
+8D82 AF11
+8D83 AF12
+8D84 AF13
+8D85 AF14
+8D86 AF15
+8D87 AF16
+8D88 AF17
+8D89 AF18
+8D8A AF19
+8D8B AF1A
+8D8C AF1B
+8D8D AF1C
+8D8E AF1D
+8D8F AF1E
+8D90 AF1F
+8D91 AF20
+8D93 AF21
+8D94 AF22
+8D95 AF23
+8D96 AF24
+8D97 AF25
+8D98 AF26
+8D99 AF27
+8D9A AF28
+8D9B AF29
+8D9C AF2A
+8D9D AF2B
+8DA1 AF2C
+8DA2 AF2D
+8DA3 AF2E
+8DA4 AF2F
+8DA5 AF30
+8DA6 AF31
+8DA7 AF32
+8DA8 AF33
+8DA9 AF34
+8DAA AF35
+8DAB AF36
+8DAC AF37
+8DAD AF38
+8DAE AF39
+8DAF AF3A
+8DB0 AF3B
+8DB1 AF3C
+8DB3 AF3D
+8DB4 AF3E
+8DB5 AF3F
+8DB6 AF40
+8DB7 AF41
+8DB8 AF42
+8DB9 AF43
+8DBA AF44
+8DBB AF45
+8DBC AF46
+8DBD AF47
+8DC1 AF48
+8DC2 AF49
+8DC3 AF4A
+8DC4 AF4B
+8DC5 AF4C
+8DC6 AF4D
+8DC7 AF4E
+8DC8 AF4F
+8DC9 AF50
+8DCA AF51
+8DCB AF52
+8DCC AF53
+8DCD AF54
+8DCE AF55
+8DCF AF56
+8DD0 AF57
+8DD1 AF58
+8DD3 AF59
+8DD4 AF5A
+8DD5 AF5B
+8DD6 AF5C
+8DD7 AF5D
+8DD8 AF5E
+8DD9 AF5F
+8DDA AF60
+8DDB AF61
+8DDC AF62
+8DDD AF63
+8DE1 AF64
+8DE2 AF65
+8DE3 AF66
+8DE4 AF67
+8DE5 AF68
+8DE6 AF69
+8DE7 AF6A
+8DE8 AF6B
+8DE9 AF6C
+8DEA AF6D
+8DEB AF6E
+8DEC AF6F
+8DED AF70
+8DEE AF71
+8DEF AF72
+8DF0 AF73
+8DF1 AF74
+8DF3 AF75
+8DF4 AF76
+8DF5 AF77
+8DF6 AF78
+8DF7 AF79
+8DF8 AF7A
+8DF9 AF7B
+8DFA AF7C
+8DFB AF7D
+8DFC AF7E
+8DFD AF7F
+8E41 AF80
+8E42 AF81
+8E43 AF82
+8E44 AF83
+8E45 AF84
+8E46 AF85
+8E47 AF86
+8E48 AF87
+8E49 AF88
+8E4A AF89
+8E4B AF8A
+8E4C AF8B
+8E4D AF8C
+8E4E AF8D
+8E4F AF8E
+8E50 AF8F
+8E51 AF90
+8E53 AF91
+8E54 AF92
+8E55 AF93
+8E56 AF94
+8E57 AF95
+8E58 AF96
+8E59 AF97
+8E5A AF98
+8E5B AF99
+8E5C AF9A
+8E5D AF9B
+8E61 AF9C
+8E62 AF9D
+8E63 AF9E
+8E64 AF9F
+8E65 AFA0
+8E66 AFA1
+8E67 AFA2
+8E68 AFA3
+8E69 AFA4
+8E6A AFA5
+8E6B AFA6
+8E6C AFA7
+8E6D AFA8
+8E6E AFA9
+8E6F AFAA
+8E70 AFAB
+8E71 AFAC
+8E73 AFAD
+8E74 AFAE
+8E75 AFAF
+8E76 AFB0
+8E77 AFB1
+8E78 AFB2
+8E79 AFB3
+8E7A AFB4
+8E7B AFB5
+8E7C AFB6
+8E7D AFB7
+8E81 AFB8
+8E82 AFB9
+8E83 AFBA
+8E84 AFBB
+8E85 AFBC
+8E86 AFBD
+8E87 AFBE
+8E88 AFBF
+8E89 AFC0
+8E8A AFC1
+8E8B AFC2
+8E8C AFC3
+8E8D AFC4
+8E8E AFC5
+8E8F AFC6
+8E90 AFC7
+8E91 AFC8
+8E93 AFC9
+8E94 AFCA
+8E95 AFCB
+8E96 AFCC
+8E97 AFCD
+8E98 AFCE
+8E99 AFCF
+8E9A AFD0
+8E9B AFD1
+8E9C AFD2
+8E9D AFD3
+8EA1 AFD4
+8EA2 AFD5
+8EA3 AFD6
+8EA4 AFD7
+8EA5 AFD8
+8EA6 AFD9
+8EA7 AFDA
+8EA8 AFDB
+8EA9 AFDC
+8EAA AFDD
+8EAB AFDE
+8EAC AFDF
+8EAD AFE0
+8EAE AFE1
+8EAF AFE2
+8EB0 AFE3
+8EB1 AFE4
+8EB3 AFE5
+8EB4 AFE6
+8EB5 AFE7
+8EB6 AFE8
+8EB7 AFE9
+8EB8 AFEA
+8EB9 AFEB
+8EBA AFEC
+8EBB AFED
+8EBC AFEE
+8EBD AFEF
+8EC1 AFF0
+8EC2 AFF1
+8EC3 AFF2
+8EC4 AFF3
+8EC5 AFF4
+8EC6 AFF5
+8EC7 AFF6
+8EC8 AFF7
+8EC9 AFF8
+8ECA AFF9
+8ECB AFFA
+8ECC AFFB
+8ECD AFFC
+8ECE AFFD
+8ECF AFFE
+8ED0 AFFF
+8ED1 B000
+8ED3 B001
+8ED4 B002
+8ED5 B003
+8ED6 B004
+8ED7 B005
+8ED8 B006
+8ED9 B007
+8EDA B008
+8EDB B009
+8EDC B00A
+8EDD B00B
+8EE1 B00C
+8EE2 B00D
+8EE3 B00E
+8EE4 B00F
+8EE5 B010
+8EE6 B011
+8EE7 B012
+8EE8 B013
+8EE9 B014
+8EEA B015
+8EEB B016
+8EEC B017
+8EED B018
+8EEE B019
+8EEF B01A
+8EF0 B01B
+8EF1 B01C
+8EF3 B01D
+8EF4 B01E
+8EF5 B01F
+8EF6 B020
+8EF7 B021
+8EF8 B022
+8EF9 B023
+8EFA B024
+8EFB B025
+8EFC B026
+8EFD B027
+8F41 B028
+8F42 B029
+8F43 B02A
+8F44 B02B
+8F45 B02C
+8F46 B02D
+8F47 B02E
+8F48 B02F
+8F49 B030
+8F4A B031
+8F4B B032
+8F4C B033
+8F4D B034
+8F4E B035
+8F4F B036
+8F50 B037
+8F51 B038
+8F53 B039
+8F54 B03A
+8F55 B03B
+8F56 B03C
+8F57 B03D
+8F58 B03E
+8F59 B03F
+8F5A B040
+8F5B B041
+8F5C B042
+8F5D B043
+8F61 B044
+8F62 B045
+8F63 B046
+8F64 B047
+8F65 B048
+8F66 B049
+8F67 B04A
+8F68 B04B
+8F69 B04C
+8F6A B04D
+8F6B B04E
+8F6C B04F
+8F6D B050
+8F6E B051
+8F6F B052
+8F70 B053
+8F71 B054
+8F73 B055
+8F74 B056
+8F75 B057
+8F76 B058
+8F77 B059
+8F78 B05A
+8F79 B05B
+8F7A B05C
+8F7B B05D
+8F7C B05E
+8F7D B05F
+8F81 B060
+8F82 B061
+8F83 B062
+8F84 B063
+8F85 B064
+8F86 B065
+8F87 B066
+8F88 B067
+8F89 B068
+8F8A B069
+8F8B B06A
+8F8C B06B
+8F8D B06C
+8F8E B06D
+8F8F B06E
+8F90 B06F
+8F91 B070
+8F93 B071
+8F94 B072
+8F95 B073
+8F96 B074
+8F97 B075
+8F98 B076
+8F99 B077
+8F9A B078
+8F9B B079
+8F9C B07A
+8F9D B07B
+8FA1 B07C
+8FA2 B07D
+8FA3 B07E
+8FA4 B07F
+8FA5 B080
+8FA6 B081
+8FA7 B082
+8FA8 B083
+8FA9 B084
+8FAA B085
+8FAB B086
+8FAC B087
+8FAD B088
+8FAE B089
+8FAF B08A
+8FB0 B08B
+8FB1 B08C
+8FB3 B08D
+8FB4 B08E
+8FB5 B08F
+8FB6 B090
+8FB7 B091
+8FB8 B092
+8FB9 B093
+8FBA B094
+8FBB B095
+8FBC B096
+8FBD B097
+9041 3134
+9061 B098
+9062 B099
+9063 B09A
+9064 B09B
+9065 B09C
+9066 B09D
+9067 B09E
+9068 B09F
+9069 B0A0
+906A B0A1
+906B B0A2
+906C B0A3
+906D B0A4
+906E B0A5
+906F B0A6
+9070 B0A7
+9071 B0A8
+9073 B0A9
+9074 B0AA
+9075 B0AB
+9076 B0AC
+9077 B0AD
+9078 B0AE
+9079 B0AF
+907A B0B0
+907B B0B1
+907C B0B2
+907D B0B3
+9081 B0B4
+9082 B0B5
+9083 B0B6
+9084 B0B7
+9085 B0B8
+9086 B0B9
+9087 B0BA
+9088 B0BB
+9089 B0BC
+908A B0BD
+908B B0BE
+908C B0BF
+908D B0C0
+908E B0C1
+908F B0C2
+9090 B0C3
+9091 B0C4
+9093 B0C5
+9094 B0C6
+9095 B0C7
+9096 B0C8
+9097 B0C9
+9098 B0CA
+9099 B0CB
+909A B0CC
+909B B0CD
+909C B0CE
+909D B0CF
+90A1 B0D0
+90A2 B0D1
+90A3 B0D2
+90A4 B0D3
+90A5 B0D4
+90A6 B0D5
+90A7 B0D6
+90A8 B0D7
+90A9 B0D8
+90AA B0D9
+90AB B0DA
+90AC B0DB
+90AD B0DC
+90AE B0DD
+90AF B0DE
+90B0 B0DF
+90B1 B0E0
+90B3 B0E1
+90B4 B0E2
+90B5 B0E3
+90B6 B0E4
+90B7 B0E5
+90B8 B0E6
+90B9 B0E7
+90BA B0E8
+90BB B0E9
+90BC B0EA
+90BD B0EB
+90C1 B0EC
+90C2 B0ED
+90C3 B0EE
+90C4 B0EF
+90C5 B0F0
+90C6 B0F1
+90C7 B0F2
+90C8 B0F3
+90C9 B0F4
+90CA B0F5
+90CB B0F6
+90CC B0F7
+90CD B0F8
+90CE B0F9
+90CF B0FA
+90D0 B0FB
+90D1 B0FC
+90D3 B0FD
+90D4 B0FE
+90D5 B0FF
+90D6 B100
+90D7 B101
+90D8 B102
+90D9 B103
+90DA B104
+90DB B105
+90DC B106
+90DD B107
+90E1 B108
+90E2 B109
+90E3 B10A
+90E4 B10B
+90E5 B10C
+90E6 B10D
+90E7 B10E
+90E8 B10F
+90E9 B110
+90EA B111
+90EB B112
+90EC B113
+90ED B114
+90EE B115
+90EF B116
+90F0 B117
+90F1 B118
+90F3 B119
+90F4 B11A
+90F5 B11B
+90F6 B11C
+90F7 B11D
+90F8 B11E
+90F9 B11F
+90FA B120
+90FB B121
+90FC B122
+90FD B123
+9141 B124
+9142 B125
+9143 B126
+9144 B127
+9145 B128
+9146 B129
+9147 B12A
+9148 B12B
+9149 B12C
+914A B12D
+914B B12E
+914C B12F
+914D B130
+914E B131
+914F B132
+9150 B133
+9151 B134
+9153 B135
+9154 B136
+9155 B137
+9156 B138
+9157 B139
+9158 B13A
+9159 B13B
+915A B13C
+915B B13D
+915C B13E
+915D B13F
+9161 B140
+9162 B141
+9163 B142
+9164 B143
+9165 B144
+9166 B145
+9167 B146
+9168 B147
+9169 B148
+916A B149
+916B B14A
+916C B14B
+916D B14C
+916E B14D
+916F B14E
+9170 B14F
+9171 B150
+9173 B151
+9174 B152
+9175 B153
+9176 B154
+9177 B155
+9178 B156
+9179 B157
+917A B158
+917B B159
+917C B15A
+917D B15B
+9181 B15C
+9182 B15D
+9183 B15E
+9184 B15F
+9185 B160
+9186 B161
+9187 B162
+9188 B163
+9189 B164
+918A B165
+918B B166
+918C B167
+918D B168
+918E B169
+918F B16A
+9190 B16B
+9191 B16C
+9193 B16D
+9194 B16E
+9195 B16F
+9196 B170
+9197 B171
+9198 B172
+9199 B173
+919A B174
+919B B175
+919C B176
+919D B177
+91A1 B178
+91A2 B179
+91A3 B17A
+91A4 B17B
+91A5 B17C
+91A6 B17D
+91A7 B17E
+91A8 B17F
+91A9 B180
+91AA B181
+91AB B182
+91AC B183
+91AD B184
+91AE B185
+91AF B186
+91B0 B187
+91B1 B188
+91B3 B189
+91B4 B18A
+91B5 B18B
+91B6 B18C
+91B7 B18D
+91B8 B18E
+91B9 B18F
+91BA B190
+91BB B191
+91BC B192
+91BD B193
+91C1 B194
+91C2 B195
+91C3 B196
+91C4 B197
+91C5 B198
+91C6 B199
+91C7 B19A
+91C8 B19B
+91C9 B19C
+91CA B19D
+91CB B19E
+91CC B19F
+91CD B1A0
+91CE B1A1
+91CF B1A2
+91D0 B1A3
+91D1 B1A4
+91D3 B1A5
+91D4 B1A6
+91D5 B1A7
+91D6 B1A8
+91D7 B1A9
+91D8 B1AA
+91D9 B1AB
+91DA B1AC
+91DB B1AD
+91DC B1AE
+91DD B1AF
+91E1 B1B0
+91E2 B1B1
+91E3 B1B2
+91E4 B1B3
+91E5 B1B4
+91E6 B1B5
+91E7 B1B6
+91E8 B1B7
+91E9 B1B8
+91EA B1B9
+91EB B1BA
+91EC B1BB
+91ED B1BC
+91EE B1BD
+91EF B1BE
+91F0 B1BF
+91F1 B1C0
+91F3 B1C1
+91F4 B1C2
+91F5 B1C3
+91F6 B1C4
+91F7 B1C5
+91F8 B1C6
+91F9 B1C7
+91FA B1C8
+91FB B1C9
+91FC B1CA
+91FD B1CB
+9241 B1CC
+9242 B1CD
+9243 B1CE
+9244 B1CF
+9245 B1D0
+9246 B1D1
+9247 B1D2
+9248 B1D3
+9249 B1D4
+924A B1D5
+924B B1D6
+924C B1D7
+924D B1D8
+924E B1D9
+924F B1DA
+9250 B1DB
+9251 B1DC
+9253 B1DD
+9254 B1DE
+9255 B1DF
+9256 B1E0
+9257 B1E1
+9258 B1E2
+9259 B1E3
+925A B1E4
+925B B1E5
+925C B1E6
+925D B1E7
+9261 B1E8
+9262 B1E9
+9263 B1EA
+9264 B1EB
+9265 B1EC
+9266 B1ED
+9267 B1EE
+9268 B1EF
+9269 B1F0
+926A B1F1
+926B B1F2
+926C B1F3
+926D B1F4
+926E B1F5
+926F B1F6
+9270 B1F7
+9271 B1F8
+9273 B1F9
+9274 B1FA
+9275 B1FB
+9276 B1FC
+9277 B1FD
+9278 B1FE
+9279 B1FF
+927A B200
+927B B201
+927C B202
+927D B203
+9281 B204
+9282 B205
+9283 B206
+9284 B207
+9285 B208
+9286 B209
+9287 B20A
+9288 B20B
+9289 B20C
+928A B20D
+928B B20E
+928C B20F
+928D B210
+928E B211
+928F B212
+9290 B213
+9291 B214
+9293 B215
+9294 B216
+9295 B217
+9296 B218
+9297 B219
+9298 B21A
+9299 B21B
+929A B21C
+929B B21D
+929C B21E
+929D B21F
+92A1 B220
+92A2 B221
+92A3 B222
+92A4 B223
+92A5 B224
+92A6 B225
+92A7 B226
+92A8 B227
+92A9 B228
+92AA B229
+92AB B22A
+92AC B22B
+92AD B22C
+92AE B22D
+92AF B22E
+92B0 B22F
+92B1 B230
+92B3 B231
+92B4 B232
+92B5 B233
+92B6 B234
+92B7 B235
+92B8 B236
+92B9 B237
+92BA B238
+92BB B239
+92BC B23A
+92BD B23B
+92C1 B23C
+92C2 B23D
+92C3 B23E
+92C4 B23F
+92C5 B240
+92C6 B241
+92C7 B242
+92C8 B243
+92C9 B244
+92CA B245
+92CB B246
+92CC B247
+92CD B248
+92CE B249
+92CF B24A
+92D0 B24B
+92D1 B24C
+92D3 B24D
+92D4 B24E
+92D5 B24F
+92D6 B250
+92D7 B251
+92D8 B252
+92D9 B253
+92DA B254
+92DB B255
+92DC B256
+92DD B257
+92E1 B258
+92E2 B259
+92E3 B25A
+92E4 B25B
+92E5 B25C
+92E6 B25D
+92E7 B25E
+92E8 B25F
+92E9 B260
+92EA B261
+92EB B262
+92EC B263
+92ED B264
+92EE B265
+92EF B266
+92F0 B267
+92F1 B268
+92F3 B269
+92F4 B26A
+92F5 B26B
+92F6 B26C
+92F7 B26D
+92F8 B26E
+92F9 B26F
+92FA B270
+92FB B271
+92FC B272
+92FD B273
+9341 B274
+9342 B275
+9343 B276
+9344 B277
+9345 B278
+9346 B279
+9347 B27A
+9348 B27B
+9349 B27C
+934A B27D
+934B B27E
+934C B27F
+934D B280
+934E B281
+934F B282
+9350 B283
+9351 B284
+9353 B285
+9354 B286
+9355 B287
+9356 B288
+9357 B289
+9358 B28A
+9359 B28B
+935A B28C
+935B B28D
+935C B28E
+935D B28F
+9361 B290
+9362 B291
+9363 B292
+9364 B293
+9365 B294
+9366 B295
+9367 B296
+9368 B297
+9369 B298
+936A B299
+936B B29A
+936C B29B
+936D B29C
+936E B29D
+936F B29E
+9370 B29F
+9371 B2A0
+9373 B2A1
+9374 B2A2
+9375 B2A3
+9376 B2A4
+9377 B2A5
+9378 B2A6
+9379 B2A7
+937A B2A8
+937B B2A9
+937C B2AA
+937D B2AB
+9381 B2AC
+9382 B2AD
+9383 B2AE
+9384 B2AF
+9385 B2B0
+9386 B2B1
+9387 B2B2
+9388 B2B3
+9389 B2B4
+938A B2B5
+938B B2B6
+938C B2B7
+938D B2B8
+938E B2B9
+938F B2BA
+9390 B2BB
+9391 B2BC
+9393 B2BD
+9394 B2BE
+9395 B2BF
+9396 B2C0
+9397 B2C1
+9398 B2C2
+9399 B2C3
+939A B2C4
+939B B2C5
+939C B2C6
+939D B2C7
+93A1 B2C8
+93A2 B2C9
+93A3 B2CA
+93A4 B2CB
+93A5 B2CC
+93A6 B2CD
+93A7 B2CE
+93A8 B2CF
+93A9 B2D0
+93AA B2D1
+93AB B2D2
+93AC B2D3
+93AD B2D4
+93AE B2D5
+93AF B2D6
+93B0 B2D7
+93B1 B2D8
+93B3 B2D9
+93B4 B2DA
+93B5 B2DB
+93B6 B2DC
+93B7 B2DD
+93B8 B2DE
+93B9 B2DF
+93BA B2E0
+93BB B2E1
+93BC B2E2
+93BD B2E3
+9441 3137
+9461 B2E4
+9462 B2E5
+9463 B2E6
+9464 B2E7
+9465 B2E8
+9466 B2E9
+9467 B2EA
+9468 B2EB
+9469 B2EC
+946A B2ED
+946B B2EE
+946C B2EF
+946D B2F0
+946E B2F1
+946F B2F2
+9470 B2F3
+9471 B2F4
+9473 B2F5
+9474 B2F6
+9475 B2F7
+9476 B2F8
+9477 B2F9
+9478 B2FA
+9479 B2FB
+947A B2FC
+947B B2FD
+947C B2FE
+947D B2FF
+9481 B300
+9482 B301
+9483 B302
+9484 B303
+9485 B304
+9486 B305
+9487 B306
+9488 B307
+9489 B308
+948A B309
+948B B30A
+948C B30B
+948D B30C
+948E B30D
+948F B30E
+9490 B30F
+9491 B310
+9493 B311
+9494 B312
+9495 B313
+9496 B314
+9497 B315
+9498 B316
+9499 B317
+949A B318
+949B B319
+949C B31A
+949D B31B
+94A1 B31C
+94A2 B31D
+94A3 B31E
+94A4 B31F
+94A5 B320
+94A6 B321
+94A7 B322
+94A8 B323
+94A9 B324
+94AA B325
+94AB B326
+94AC B327
+94AD B328
+94AE B329
+94AF B32A
+94B0 B32B
+94B1 B32C
+94B3 B32D
+94B4 B32E
+94B5 B32F
+94B6 B330
+94B7 B331
+94B8 B332
+94B9 B333
+94BA B334
+94BB B335
+94BC B336
+94BD B337
+94C1 B338
+94C2 B339
+94C3 B33A
+94C4 B33B
+94C5 B33C
+94C6 B33D
+94C7 B33E
+94C8 B33F
+94C9 B340
+94CA B341
+94CB B342
+94CC B343
+94CD B344
+94CE B345
+94CF B346
+94D0 B347
+94D1 B348
+94D3 B349
+94D4 B34A
+94D5 B34B
+94D6 B34C
+94D7 B34D
+94D8 B34E
+94D9 B34F
+94DA B350
+94DB B351
+94DC B352
+94DD B353
+94E1 B354
+94E2 B355
+94E3 B356
+94E4 B357
+94E5 B358
+94E6 B359
+94E7 B35A
+94E8 B35B
+94E9 B35C
+94EA B35D
+94EB B35E
+94EC B35F
+94ED B360
+94EE B361
+94EF B362
+94F0 B363
+94F1 B364
+94F3 B365
+94F4 B366
+94F5 B367
+94F6 B368
+94F7 B369
+94F8 B36A
+94F9 B36B
+94FA B36C
+94FB B36D
+94FC B36E
+94FD B36F
+9541 B370
+9542 B371
+9543 B372
+9544 B373
+9545 B374
+9546 B375
+9547 B376
+9548 B377
+9549 B378
+954A B379
+954B B37A
+954C B37B
+954D B37C
+954E B37D
+954F B37E
+9550 B37F
+9551 B380
+9553 B381
+9554 B382
+9555 B383
+9556 B384
+9557 B385
+9558 B386
+9559 B387
+955A B388
+955B B389
+955C B38A
+955D B38B
+9561 B38C
+9562 B38D
+9563 B38E
+9564 B38F
+9565 B390
+9566 B391
+9567 B392
+9568 B393
+9569 B394
+956A B395
+956B B396
+956C B397
+956D B398
+956E B399
+956F B39A
+9570 B39B
+9571 B39C
+9573 B39D
+9574 B39E
+9575 B39F
+9576 B3A0
+9577 B3A1
+9578 B3A2
+9579 B3A3
+957A B3A4
+957B B3A5
+957C B3A6
+957D B3A7
+9581 B3A8
+9582 B3A9
+9583 B3AA
+9584 B3AB
+9585 B3AC
+9586 B3AD
+9587 B3AE
+9588 B3AF
+9589 B3B0
+958A B3B1
+958B B3B2
+958C B3B3
+958D B3B4
+958E B3B5
+958F B3B6
+9590 B3B7
+9591 B3B8
+9593 B3B9
+9594 B3BA
+9595 B3BB
+9596 B3BC
+9597 B3BD
+9598 B3BE
+9599 B3BF
+959A B3C0
+959B B3C1
+959C B3C2
+959D B3C3
+95A1 B3C4
+95A2 B3C5
+95A3 B3C6
+95A4 B3C7
+95A5 B3C8
+95A6 B3C9
+95A7 B3CA
+95A8 B3CB
+95A9 B3CC
+95AA B3CD
+95AB B3CE
+95AC B3CF
+95AD B3D0
+95AE B3D1
+95AF B3D2
+95B0 B3D3
+95B1 B3D4
+95B3 B3D5
+95B4 B3D6
+95B5 B3D7
+95B6 B3D8
+95B7 B3D9
+95B8 B3DA
+95B9 B3DB
+95BA B3DC
+95BB B3DD
+95BC B3DE
+95BD B3DF
+95C1 B3E0
+95C2 B3E1
+95C3 B3E2
+95C4 B3E3
+95C5 B3E4
+95C6 B3E5
+95C7 B3E6
+95C8 B3E7
+95C9 B3E8
+95CA B3E9
+95CB B3EA
+95CC B3EB
+95CD B3EC
+95CE B3ED
+95CF B3EE
+95D0 B3EF
+95D1 B3F0
+95D3 B3F1
+95D4 B3F2
+95D5 B3F3
+95D6 B3F4
+95D7 B3F5
+95D8 B3F6
+95D9 B3F7
+95DA B3F8
+95DB B3F9
+95DC B3FA
+95DD B3FB
+95E1 B3FC
+95E2 B3FD
+95E3 B3FE
+95E4 B3FF
+95E5 B400
+95E6 B401
+95E7 B402
+95E8 B403
+95E9 B404
+95EA B405
+95EB B406
+95EC B407
+95ED B408
+95EE B409
+95EF B40A
+95F0 B40B
+95F1 B40C
+95F3 B40D
+95F4 B40E
+95F5 B40F
+95F6 B410
+95F7 B411
+95F8 B412
+95F9 B413
+95FA B414
+95FB B415
+95FC B416
+95FD B417
+9641 B418
+9642 B419
+9643 B41A
+9644 B41B
+9645 B41C
+9646 B41D
+9647 B41E
+9648 B41F
+9649 B420
+964A B421
+964B B422
+964C B423
+964D B424
+964E B425
+964F B426
+9650 B427
+9651 B428
+9653 B429
+9654 B42A
+9655 B42B
+9656 B42C
+9657 B42D
+9658 B42E
+9659 B42F
+965A B430
+965B B431
+965C B432
+965D B433
+9661 B434
+9662 B435
+9663 B436
+9664 B437
+9665 B438
+9666 B439
+9667 B43A
+9668 B43B
+9669 B43C
+966A B43D
+966B B43E
+966C B43F
+966D B440
+966E B441
+966F B442
+9670 B443
+9671 B444
+9673 B445
+9674 B446
+9675 B447
+9676 B448
+9677 B449
+9678 B44A
+9679 B44B
+967A B44C
+967B B44D
+967C B44E
+967D B44F
+9681 B450
+9682 B451
+9683 B452
+9684 B453
+9685 B454
+9686 B455
+9687 B456
+9688 B457
+9689 B458
+968A B459
+968B B45A
+968C B45B
+968D B45C
+968E B45D
+968F B45E
+9690 B45F
+9691 B460
+9693 B461
+9694 B462
+9695 B463
+9696 B464
+9697 B465
+9698 B466
+9699 B467
+969A B468
+969B B469
+969C B46A
+969D B46B
+96A1 B46C
+96A2 B46D
+96A3 B46E
+96A4 B46F
+96A5 B470
+96A6 B471
+96A7 B472
+96A8 B473
+96A9 B474
+96AA B475
+96AB B476
+96AC B477
+96AD B478
+96AE B479
+96AF B47A
+96B0 B47B
+96B1 B47C
+96B3 B47D
+96B4 B47E
+96B5 B47F
+96B6 B480
+96B7 B481
+96B8 B482
+96B9 B483
+96BA B484
+96BB B485
+96BC B486
+96BD B487
+96C1 B488
+96C2 B489
+96C3 B48A
+96C4 B48B
+96C5 B48C
+96C6 B48D
+96C7 B48E
+96C8 B48F
+96C9 B490
+96CA B491
+96CB B492
+96CC B493
+96CD B494
+96CE B495
+96CF B496
+96D0 B497
+96D1 B498
+96D3 B499
+96D4 B49A
+96D5 B49B
+96D6 B49C
+96D7 B49D
+96D8 B49E
+96D9 B49F
+96DA B4A0
+96DB B4A1
+96DC B4A2
+96DD B4A3
+96E1 B4A4
+96E2 B4A5
+96E3 B4A6
+96E4 B4A7
+96E5 B4A8
+96E6 B4A9
+96E7 B4AA
+96E8 B4AB
+96E9 B4AC
+96EA B4AD
+96EB B4AE
+96EC B4AF
+96ED B4B0
+96EE B4B1
+96EF B4B2
+96F0 B4B3
+96F1 B4B4
+96F3 B4B5
+96F4 B4B6
+96F5 B4B7
+96F6 B4B8
+96F7 B4B9
+96F8 B4BA
+96F9 B4BB
+96FA B4BC
+96FB B4BD
+96FC B4BE
+96FD B4BF
+9741 B4C0
+9742 B4C1
+9743 B4C2
+9744 B4C3
+9745 B4C4
+9746 B4C5
+9747 B4C6
+9748 B4C7
+9749 B4C8
+974A B4C9
+974B B4CA
+974C B4CB
+974D B4CC
+974E B4CD
+974F B4CE
+9750 B4CF
+9751 B4D0
+9753 B4D1
+9754 B4D2
+9755 B4D3
+9756 B4D4
+9757 B4D5
+9758 B4D6
+9759 B4D7
+975A B4D8
+975B B4D9
+975C B4DA
+975D B4DB
+9761 B4DC
+9762 B4DD
+9763 B4DE
+9764 B4DF
+9765 B4E0
+9766 B4E1
+9767 B4E2
+9768 B4E3
+9769 B4E4
+976A B4E5
+976B B4E6
+976C B4E7
+976D B4E8
+976E B4E9
+976F B4EA
+9770 B4EB
+9771 B4EC
+9773 B4ED
+9774 B4EE
+9775 B4EF
+9776 B4F0
+9777 B4F1
+9778 B4F2
+9779 B4F3
+977A B4F4
+977B B4F5
+977C B4F6
+977D B4F7
+9781 B4F8
+9782 B4F9
+9783 B4FA
+9784 B4FB
+9785 B4FC
+9786 B4FD
+9787 B4FE
+9788 B4FF
+9789 B500
+978A B501
+978B B502
+978C B503
+978D B504
+978E B505
+978F B506
+9790 B507
+9791 B508
+9793 B509
+9794 B50A
+9795 B50B
+9796 B50C
+9797 B50D
+9798 B50E
+9799 B50F
+979A B510
+979B B511
+979C B512
+979D B513
+97A1 B514
+97A2 B515
+97A3 B516
+97A4 B517
+97A5 B518
+97A6 B519
+97A7 B51A
+97A8 B51B
+97A9 B51C
+97AA B51D
+97AB B51E
+97AC B51F
+97AD B520
+97AE B521
+97AF B522
+97B0 B523
+97B1 B524
+97B3 B525
+97B4 B526
+97B5 B527
+97B6 B528
+97B7 B529
+97B8 B52A
+97B9 B52B
+97BA B52C
+97BB B52D
+97BC B52E
+97BD B52F
+9841 3138
+9861 B530
+9862 B531
+9863 B532
+9864 B533
+9865 B534
+9866 B535
+9867 B536
+9868 B537
+9869 B538
+986A B539
+986B B53A
+986C B53B
+986D B53C
+986E B53D
+986F B53E
+9870 B53F
+9871 B540
+9873 B541
+9874 B542
+9875 B543
+9876 B544
+9877 B545
+9878 B546
+9879 B547
+987A B548
+987B B549
+987C B54A
+987D B54B
+9881 B54C
+9882 B54D
+9883 B54E
+9884 B54F
+9885 B550
+9886 B551
+9887 B552
+9888 B553
+9889 B554
+988A B555
+988B B556
+988C B557
+988D B558
+988E B559
+988F B55A
+9890 B55B
+9891 B55C
+9893 B55D
+9894 B55E
+9895 B55F
+9896 B560
+9897 B561
+9898 B562
+9899 B563
+989A B564
+989B B565
+989C B566
+989D B567
+98A1 B568
+98A2 B569
+98A3 B56A
+98A4 B56B
+98A5 B56C
+98A6 B56D
+98A7 B56E
+98A8 B56F
+98A9 B570
+98AA B571
+98AB B572
+98AC B573
+98AD B574
+98AE B575
+98AF B576
+98B0 B577
+98B1 B578
+98B3 B579
+98B4 B57A
+98B5 B57B
+98B6 B57C
+98B7 B57D
+98B8 B57E
+98B9 B57F
+98BA B580
+98BB B581
+98BC B582
+98BD B583
+98C1 B584
+98C2 B585
+98C3 B586
+98C4 B587
+98C5 B588
+98C6 B589
+98C7 B58A
+98C8 B58B
+98C9 B58C
+98CA B58D
+98CB B58E
+98CC B58F
+98CD B590
+98CE B591
+98CF B592
+98D0 B593
+98D1 B594
+98D3 B595
+98D4 B596
+98D5 B597
+98D6 B598
+98D7 B599
+98D8 B59A
+98D9 B59B
+98DA B59C
+98DB B59D
+98DC B59E
+98DD B59F
+98E1 B5A0
+98E2 B5A1
+98E3 B5A2
+98E4 B5A3
+98E5 B5A4
+98E6 B5A5
+98E7 B5A6
+98E8 B5A7
+98E9 B5A8
+98EA B5A9
+98EB B5AA
+98EC B5AB
+98ED B5AC
+98EE B5AD
+98EF B5AE
+98F0 B5AF
+98F1 B5B0
+98F3 B5B1
+98F4 B5B2
+98F5 B5B3
+98F6 B5B4
+98F7 B5B5
+98F8 B5B6
+98F9 B5B7
+98FA B5B8
+98FB B5B9
+98FC B5BA
+98FD B5BB
+9941 B5BC
+9942 B5BD
+9943 B5BE
+9944 B5BF
+9945 B5C0
+9946 B5C1
+9947 B5C2
+9948 B5C3
+9949 B5C4
+994A B5C5
+994B B5C6
+994C B5C7
+994D B5C8
+994E B5C9
+994F B5CA
+9950 B5CB
+9951 B5CC
+9953 B5CD
+9954 B5CE
+9955 B5CF
+9956 B5D0
+9957 B5D1
+9958 B5D2
+9959 B5D3
+995A B5D4
+995B B5D5
+995C B5D6
+995D B5D7
+9961 B5D8
+9962 B5D9
+9963 B5DA
+9964 B5DB
+9965 B5DC
+9966 B5DD
+9967 B5DE
+9968 B5DF
+9969 B5E0
+996A B5E1
+996B B5E2
+996C B5E3
+996D B5E4
+996E B5E5
+996F B5E6
+9970 B5E7
+9971 B5E8
+9973 B5E9
+9974 B5EA
+9975 B5EB
+9976 B5EC
+9977 B5ED
+9978 B5EE
+9979 B5EF
+997A B5F0
+997B B5F1
+997C B5F2
+997D B5F3
+9981 B5F4
+9982 B5F5
+9983 B5F6
+9984 B5F7
+9985 B5F8
+9986 B5F9
+9987 B5FA
+9988 B5FB
+9989 B5FC
+998A B5FD
+998B B5FE
+998C B5FF
+998D B600
+998E B601
+998F B602
+9990 B603
+9991 B604
+9993 B605
+9994 B606
+9995 B607
+9996 B608
+9997 B609
+9998 B60A
+9999 B60B
+999A B60C
+999B B60D
+999C B60E
+999D B60F
+99A1 B610
+99A2 B611
+99A3 B612
+99A4 B613
+99A5 B614
+99A6 B615
+99A7 B616
+99A8 B617
+99A9 B618
+99AA B619
+99AB B61A
+99AC B61B
+99AD B61C
+99AE B61D
+99AF B61E
+99B0 B61F
+99B1 B620
+99B3 B621
+99B4 B622
+99B5 B623
+99B6 B624
+99B7 B625
+99B8 B626
+99B9 B627
+99BA B628
+99BB B629
+99BC B62A
+99BD B62B
+99C1 B62C
+99C2 B62D
+99C3 B62E
+99C4 B62F
+99C5 B630
+99C6 B631
+99C7 B632
+99C8 B633
+99C9 B634
+99CA B635
+99CB B636
+99CC B637
+99CD B638
+99CE B639
+99CF B63A
+99D0 B63B
+99D1 B63C
+99D3 B63D
+99D4 B63E
+99D5 B63F
+99D6 B640
+99D7 B641
+99D8 B642
+99D9 B643
+99DA B644
+99DB B645
+99DC B646
+99DD B647
+99E1 B648
+99E2 B649
+99E3 B64A
+99E4 B64B
+99E5 B64C
+99E6 B64D
+99E7 B64E
+99E8 B64F
+99E9 B650
+99EA B651
+99EB B652
+99EC B653
+99ED B654
+99EE B655
+99EF B656
+99F0 B657
+99F1 B658
+99F3 B659
+99F4 B65A
+99F5 B65B
+99F6 B65C
+99F7 B65D
+99F8 B65E
+99F9 B65F
+99FA B660
+99FB B661
+99FC B662
+99FD B663
+9A41 B664
+9A42 B665
+9A43 B666
+9A44 B667
+9A45 B668
+9A46 B669
+9A47 B66A
+9A48 B66B
+9A49 B66C
+9A4A B66D
+9A4B B66E
+9A4C B66F
+9A4D B670
+9A4E B671
+9A4F B672
+9A50 B673
+9A51 B674
+9A53 B675
+9A54 B676
+9A55 B677
+9A56 B678
+9A57 B679
+9A58 B67A
+9A59 B67B
+9A5A B67C
+9A5B B67D
+9A5C B67E
+9A5D B67F
+9A61 B680
+9A62 B681
+9A63 B682
+9A64 B683
+9A65 B684
+9A66 B685
+9A67 B686
+9A68 B687
+9A69 B688
+9A6A B689
+9A6B B68A
+9A6C B68B
+9A6D B68C
+9A6E B68D
+9A6F B68E
+9A70 B68F
+9A71 B690
+9A73 B691
+9A74 B692
+9A75 B693
+9A76 B694
+9A77 B695
+9A78 B696
+9A79 B697
+9A7A B698
+9A7B B699
+9A7C B69A
+9A7D B69B
+9A81 B69C
+9A82 B69D
+9A83 B69E
+9A84 B69F
+9A85 B6A0
+9A86 B6A1
+9A87 B6A2
+9A88 B6A3
+9A89 B6A4
+9A8A B6A5
+9A8B B6A6
+9A8C B6A7
+9A8D B6A8
+9A8E B6A9
+9A8F B6AA
+9A90 B6AB
+9A91 B6AC
+9A93 B6AD
+9A94 B6AE
+9A95 B6AF
+9A96 B6B0
+9A97 B6B1
+9A98 B6B2
+9A99 B6B3
+9A9A B6B4
+9A9B B6B5
+9A9C B6B6
+9A9D B6B7
+9AA1 B6B8
+9AA2 B6B9
+9AA3 B6BA
+9AA4 B6BB
+9AA5 B6BC
+9AA6 B6BD
+9AA7 B6BE
+9AA8 B6BF
+9AA9 B6C0
+9AAA B6C1
+9AAB B6C2
+9AAC B6C3
+9AAD B6C4
+9AAE B6C5
+9AAF B6C6
+9AB0 B6C7
+9AB1 B6C8
+9AB3 B6C9
+9AB4 B6CA
+9AB5 B6CB
+9AB6 B6CC
+9AB7 B6CD
+9AB8 B6CE
+9AB9 B6CF
+9ABA B6D0
+9ABB B6D1
+9ABC B6D2
+9ABD B6D3
+9AC1 B6D4
+9AC2 B6D5
+9AC3 B6D6
+9AC4 B6D7
+9AC5 B6D8
+9AC6 B6D9
+9AC7 B6DA
+9AC8 B6DB
+9AC9 B6DC
+9ACA B6DD
+9ACB B6DE
+9ACC B6DF
+9ACD B6E0
+9ACE B6E1
+9ACF B6E2
+9AD0 B6E3
+9AD1 B6E4
+9AD3 B6E5
+9AD4 B6E6
+9AD5 B6E7
+9AD6 B6E8
+9AD7 B6E9
+9AD8 B6EA
+9AD9 B6EB
+9ADA B6EC
+9ADB B6ED
+9ADC B6EE
+9ADD B6EF
+9AE1 B6F0
+9AE2 B6F1
+9AE3 B6F2
+9AE4 B6F3
+9AE5 B6F4
+9AE6 B6F5
+9AE7 B6F6
+9AE8 B6F7
+9AE9 B6F8
+9AEA B6F9
+9AEB B6FA
+9AEC B6FB
+9AED B6FC
+9AEE B6FD
+9AEF B6FE
+9AF0 B6FF
+9AF1 B700
+9AF3 B701
+9AF4 B702
+9AF5 B703
+9AF6 B704
+9AF7 B705
+9AF8 B706
+9AF9 B707
+9AFA B708
+9AFB B709
+9AFC B70A
+9AFD B70B
+9B41 B70C
+9B42 B70D
+9B43 B70E
+9B44 B70F
+9B45 B710
+9B46 B711
+9B47 B712
+9B48 B713
+9B49 B714
+9B4A B715
+9B4B B716
+9B4C B717
+9B4D B718
+9B4E B719
+9B4F B71A
+9B50 B71B
+9B51 B71C
+9B53 B71D
+9B54 B71E
+9B55 B71F
+9B56 B720
+9B57 B721
+9B58 B722
+9B59 B723
+9B5A B724
+9B5B B725
+9B5C B726
+9B5D B727
+9B61 B728
+9B62 B729
+9B63 B72A
+9B64 B72B
+9B65 B72C
+9B66 B72D
+9B67 B72E
+9B68 B72F
+9B69 B730
+9B6A B731
+9B6B B732
+9B6C B733
+9B6D B734
+9B6E B735
+9B6F B736
+9B70 B737
+9B71 B738
+9B73 B739
+9B74 B73A
+9B75 B73B
+9B76 B73C
+9B77 B73D
+9B78 B73E
+9B79 B73F
+9B7A B740
+9B7B B741
+9B7C B742
+9B7D B743
+9B81 B744
+9B82 B745
+9B83 B746
+9B84 B747
+9B85 B748
+9B86 B749
+9B87 B74A
+9B88 B74B
+9B89 B74C
+9B8A B74D
+9B8B B74E
+9B8C B74F
+9B8D B750
+9B8E B751
+9B8F B752
+9B90 B753
+9B91 B754
+9B93 B755
+9B94 B756
+9B95 B757
+9B96 B758
+9B97 B759
+9B98 B75A
+9B99 B75B
+9B9A B75C
+9B9B B75D
+9B9C B75E
+9B9D B75F
+9BA1 B760
+9BA2 B761
+9BA3 B762
+9BA4 B763
+9BA5 B764
+9BA6 B765
+9BA7 B766
+9BA8 B767
+9BA9 B768
+9BAA B769
+9BAB B76A
+9BAC B76B
+9BAD B76C
+9BAE B76D
+9BAF B76E
+9BB0 B76F
+9BB1 B770
+9BB3 B771
+9BB4 B772
+9BB5 B773
+9BB6 B774
+9BB7 B775
+9BB8 B776
+9BB9 B777
+9BBA B778
+9BBB B779
+9BBC B77A
+9BBD B77B
+9C41 3139
+9C61 B77C
+9C62 B77D
+9C63 B77E
+9C64 B77F
+9C65 B780
+9C66 B781
+9C67 B782
+9C68 B783
+9C69 B784
+9C6A B785
+9C6B B786
+9C6C B787
+9C6D B788
+9C6E B789
+9C6F B78A
+9C70 B78B
+9C71 B78C
+9C73 B78D
+9C74 B78E
+9C75 B78F
+9C76 B790
+9C77 B791
+9C78 B792
+9C79 B793
+9C7A B794
+9C7B B795
+9C7C B796
+9C7D B797
+9C81 B798
+9C82 B799
+9C83 B79A
+9C84 B79B
+9C85 B79C
+9C86 B79D
+9C87 B79E
+9C88 B79F
+9C89 B7A0
+9C8A B7A1
+9C8B B7A2
+9C8C B7A3
+9C8D B7A4
+9C8E B7A5
+9C8F B7A6
+9C90 B7A7
+9C91 B7A8
+9C93 B7A9
+9C94 B7AA
+9C95 B7AB
+9C96 B7AC
+9C97 B7AD
+9C98 B7AE
+9C99 B7AF
+9C9A B7B0
+9C9B B7B1
+9C9C B7B2
+9C9D B7B3
+9CA1 B7B4
+9CA2 B7B5
+9CA3 B7B6
+9CA4 B7B7
+9CA5 B7B8
+9CA6 B7B9
+9CA7 B7BA
+9CA8 B7BB
+9CA9 B7BC
+9CAA B7BD
+9CAB B7BE
+9CAC B7BF
+9CAD B7C0
+9CAE B7C1
+9CAF B7C2
+9CB0 B7C3
+9CB1 B7C4
+9CB3 B7C5
+9CB4 B7C6
+9CB5 B7C7
+9CB6 B7C8
+9CB7 B7C9
+9CB8 B7CA
+9CB9 B7CB
+9CBA B7CC
+9CBB B7CD
+9CBC B7CE
+9CBD B7CF
+9CC1 B7D0
+9CC2 B7D1
+9CC3 B7D2
+9CC4 B7D3
+9CC5 B7D4
+9CC6 B7D5
+9CC7 B7D6
+9CC8 B7D7
+9CC9 B7D8
+9CCA B7D9
+9CCB B7DA
+9CCC B7DB
+9CCD B7DC
+9CCE B7DD
+9CCF B7DE
+9CD0 B7DF
+9CD1 B7E0
+9CD3 B7E1
+9CD4 B7E2
+9CD5 B7E3
+9CD6 B7E4
+9CD7 B7E5
+9CD8 B7E6
+9CD9 B7E7
+9CDA B7E8
+9CDB B7E9
+9CDC B7EA
+9CDD B7EB
+9CE1 B7EC
+9CE2 B7ED
+9CE3 B7EE
+9CE4 B7EF
+9CE5 B7F0
+9CE6 B7F1
+9CE7 B7F2
+9CE8 B7F3
+9CE9 B7F4
+9CEA B7F5
+9CEB B7F6
+9CEC B7F7
+9CED B7F8
+9CEE B7F9
+9CEF B7FA
+9CF0 B7FB
+9CF1 B7FC
+9CF3 B7FD
+9CF4 B7FE
+9CF5 B7FF
+9CF6 B800
+9CF7 B801
+9CF8 B802
+9CF9 B803
+9CFA B804
+9CFB B805
+9CFC B806
+9CFD B807
+9D41 B808
+9D42 B809
+9D43 B80A
+9D44 B80B
+9D45 B80C
+9D46 B80D
+9D47 B80E
+9D48 B80F
+9D49 B810
+9D4A B811
+9D4B B812
+9D4C B813
+9D4D B814
+9D4E B815
+9D4F B816
+9D50 B817
+9D51 B818
+9D53 B819
+9D54 B81A
+9D55 B81B
+9D56 B81C
+9D57 B81D
+9D58 B81E
+9D59 B81F
+9D5A B820
+9D5B B821
+9D5C B822
+9D5D B823
+9D61 B824
+9D62 B825
+9D63 B826
+9D64 B827
+9D65 B828
+9D66 B829
+9D67 B82A
+9D68 B82B
+9D69 B82C
+9D6A B82D
+9D6B B82E
+9D6C B82F
+9D6D B830
+9D6E B831
+9D6F B832
+9D70 B833
+9D71 B834
+9D73 B835
+9D74 B836
+9D75 B837
+9D76 B838
+9D77 B839
+9D78 B83A
+9D79 B83B
+9D7A B83C
+9D7B B83D
+9D7C B83E
+9D7D B83F
+9D81 B840
+9D82 B841
+9D83 B842
+9D84 B843
+9D85 B844
+9D86 B845
+9D87 B846
+9D88 B847
+9D89 B848
+9D8A B849
+9D8B B84A
+9D8C B84B
+9D8D B84C
+9D8E B84D
+9D8F B84E
+9D90 B84F
+9D91 B850
+9D93 B851
+9D94 B852
+9D95 B853
+9D96 B854
+9D97 B855
+9D98 B856
+9D99 B857
+9D9A B858
+9D9B B859
+9D9C B85A
+9D9D B85B
+9DA1 B85C
+9DA2 B85D
+9DA3 B85E
+9DA4 B85F
+9DA5 B860
+9DA6 B861
+9DA7 B862
+9DA8 B863
+9DA9 B864
+9DAA B865
+9DAB B866
+9DAC B867
+9DAD B868
+9DAE B869
+9DAF B86A
+9DB0 B86B
+9DB1 B86C
+9DB3 B86D
+9DB4 B86E
+9DB5 B86F
+9DB6 B870
+9DB7 B871
+9DB8 B872
+9DB9 B873
+9DBA B874
+9DBB B875
+9DBC B876
+9DBD B877
+9DC1 B878
+9DC2 B879
+9DC3 B87A
+9DC4 B87B
+9DC5 B87C
+9DC6 B87D
+9DC7 B87E
+9DC8 B87F
+9DC9 B880
+9DCA B881
+9DCB B882
+9DCC B883
+9DCD B884
+9DCE B885
+9DCF B886
+9DD0 B887
+9DD1 B888
+9DD3 B889
+9DD4 B88A
+9DD5 B88B
+9DD6 B88C
+9DD7 B88D
+9DD8 B88E
+9DD9 B88F
+9DDA B890
+9DDB B891
+9DDC B892
+9DDD B893
+9DE1 B894
+9DE2 B895
+9DE3 B896
+9DE4 B897
+9DE5 B898
+9DE6 B899
+9DE7 B89A
+9DE8 B89B
+9DE9 B89C
+9DEA B89D
+9DEB B89E
+9DEC B89F
+9DED B8A0
+9DEE B8A1
+9DEF B8A2
+9DF0 B8A3
+9DF1 B8A4
+9DF3 B8A5
+9DF4 B8A6
+9DF5 B8A7
+9DF6 B8A8
+9DF7 B8A9
+9DF8 B8AA
+9DF9 B8AB
+9DFA B8AC
+9DFB B8AD
+9DFC B8AE
+9DFD B8AF
+9E41 B8B0
+9E42 B8B1
+9E43 B8B2
+9E44 B8B3
+9E45 B8B4
+9E46 B8B5
+9E47 B8B6
+9E48 B8B7
+9E49 B8B8
+9E4A B8B9
+9E4B B8BA
+9E4C B8BB
+9E4D B8BC
+9E4E B8BD
+9E4F B8BE
+9E50 B8BF
+9E51 B8C0
+9E53 B8C1
+9E54 B8C2
+9E55 B8C3
+9E56 B8C4
+9E57 B8C5
+9E58 B8C6
+9E59 B8C7
+9E5A B8C8
+9E5B B8C9
+9E5C B8CA
+9E5D B8CB
+9E61 B8CC
+9E62 B8CD
+9E63 B8CE
+9E64 B8CF
+9E65 B8D0
+9E66 B8D1
+9E67 B8D2
+9E68 B8D3
+9E69 B8D4
+9E6A B8D5
+9E6B B8D6
+9E6C B8D7
+9E6D B8D8
+9E6E B8D9
+9E6F B8DA
+9E70 B8DB
+9E71 B8DC
+9E73 B8DD
+9E74 B8DE
+9E75 B8DF
+9E76 B8E0
+9E77 B8E1
+9E78 B8E2
+9E79 B8E3
+9E7A B8E4
+9E7B B8E5
+9E7C B8E6
+9E7D B8E7
+9E81 B8E8
+9E82 B8E9
+9E83 B8EA
+9E84 B8EB
+9E85 B8EC
+9E86 B8ED
+9E87 B8EE
+9E88 B8EF
+9E89 B8F0
+9E8A B8F1
+9E8B B8F2
+9E8C B8F3
+9E8D B8F4
+9E8E B8F5
+9E8F B8F6
+9E90 B8F7
+9E91 B8F8
+9E93 B8F9
+9E94 B8FA
+9E95 B8FB
+9E96 B8FC
+9E97 B8FD
+9E98 B8FE
+9E99 B8FF
+9E9A B900
+9E9B B901
+9E9C B902
+9E9D B903
+9EA1 B904
+9EA2 B905
+9EA3 B906
+9EA4 B907
+9EA5 B908
+9EA6 B909
+9EA7 B90A
+9EA8 B90B
+9EA9 B90C
+9EAA B90D
+9EAB B90E
+9EAC B90F
+9EAD B910
+9EAE B911
+9EAF B912
+9EB0 B913
+9EB1 B914
+9EB3 B915
+9EB4 B916
+9EB5 B917
+9EB6 B918
+9EB7 B919
+9EB8 B91A
+9EB9 B91B
+9EBA B91C
+9EBB B91D
+9EBC B91E
+9EBD B91F
+9EC1 B920
+9EC2 B921
+9EC3 B922
+9EC4 B923
+9EC5 B924
+9EC6 B925
+9EC7 B926
+9EC8 B927
+9EC9 B928
+9ECA B929
+9ECB B92A
+9ECC B92B
+9ECD B92C
+9ECE B92D
+9ECF B92E
+9ED0 B92F
+9ED1 B930
+9ED3 B931
+9ED4 B932
+9ED5 B933
+9ED6 B934
+9ED7 B935
+9ED8 B936
+9ED9 B937
+9EDA B938
+9EDB B939
+9EDC B93A
+9EDD B93B
+9EE1 B93C
+9EE2 B93D
+9EE3 B93E
+9EE4 B93F
+9EE5 B940
+9EE6 B941
+9EE7 B942
+9EE8 B943
+9EE9 B944
+9EEA B945
+9EEB B946
+9EEC B947
+9EED B948
+9EEE B949
+9EEF B94A
+9EF0 B94B
+9EF1 B94C
+9EF3 B94D
+9EF4 B94E
+9EF5 B94F
+9EF6 B950
+9EF7 B951
+9EF8 B952
+9EF9 B953
+9EFA B954
+9EFB B955
+9EFC B956
+9EFD B957
+9F41 B958
+9F42 B959
+9F43 B95A
+9F44 B95B
+9F45 B95C
+9F46 B95D
+9F47 B95E
+9F48 B95F
+9F49 B960
+9F4A B961
+9F4B B962
+9F4C B963
+9F4D B964
+9F4E B965
+9F4F B966
+9F50 B967
+9F51 B968
+9F53 B969
+9F54 B96A
+9F55 B96B
+9F56 B96C
+9F57 B96D
+9F58 B96E
+9F59 B96F
+9F5A B970
+9F5B B971
+9F5C B972
+9F5D B973
+9F61 B974
+9F62 B975
+9F63 B976
+9F64 B977
+9F65 B978
+9F66 B979
+9F67 B97A
+9F68 B97B
+9F69 B97C
+9F6A B97D
+9F6B B97E
+9F6C B97F
+9F6D B980
+9F6E B981
+9F6F B982
+9F70 B983
+9F71 B984
+9F73 B985
+9F74 B986
+9F75 B987
+9F76 B988
+9F77 B989
+9F78 B98A
+9F79 B98B
+9F7A B98C
+9F7B B98D
+9F7C B98E
+9F7D B98F
+9F81 B990
+9F82 B991
+9F83 B992
+9F84 B993
+9F85 B994
+9F86 B995
+9F87 B996
+9F88 B997
+9F89 B998
+9F8A B999
+9F8B B99A
+9F8C B99B
+9F8D B99C
+9F8E B99D
+9F8F B99E
+9F90 B99F
+9F91 B9A0
+9F93 B9A1
+9F94 B9A2
+9F95 B9A3
+9F96 B9A4
+9F97 B9A5
+9F98 B9A6
+9F99 B9A7
+9F9A B9A8
+9F9B B9A9
+9F9C B9AA
+9F9D B9AB
+9FA1 B9AC
+9FA2 B9AD
+9FA3 B9AE
+9FA4 B9AF
+9FA5 B9B0
+9FA6 B9B1
+9FA7 B9B2
+9FA8 B9B3
+9FA9 B9B4
+9FAA B9B5
+9FAB B9B6
+9FAC B9B7
+9FAD B9B8
+9FAE B9B9
+9FAF B9BA
+9FB0 B9BB
+9FB1 B9BC
+9FB3 B9BD
+9FB4 B9BE
+9FB5 B9BF
+9FB6 B9C0
+9FB7 B9C1
+9FB8 B9C2
+9FB9 B9C3
+9FBA B9C4
+9FBB B9C5
+9FBC B9C6
+9FBD B9C7
+A041 3141
+A061 B9C8
+A062 B9C9
+A063 B9CA
+A064 B9CB
+A065 B9CC
+A066 B9CD
+A067 B9CE
+A068 B9CF
+A069 B9D0
+A06A B9D1
+A06B B9D2
+A06C B9D3
+A06D B9D4
+A06E B9D5
+A06F B9D6
+A070 B9D7
+A071 B9D8
+A073 B9D9
+A074 B9DA
+A075 B9DB
+A076 B9DC
+A077 B9DD
+A078 B9DE
+A079 B9DF
+A07A B9E0
+A07B B9E1
+A07C B9E2
+A07D B9E3
+A081 B9E4
+A082 B9E5
+A083 B9E6
+A084 B9E7
+A085 B9E8
+A086 B9E9
+A087 B9EA
+A088 B9EB
+A089 B9EC
+A08A B9ED
+A08B B9EE
+A08C B9EF
+A08D B9F0
+A08E B9F1
+A08F B9F2
+A090 B9F3
+A091 B9F4
+A093 B9F5
+A094 B9F6
+A095 B9F7
+A096 B9F8
+A097 B9F9
+A098 B9FA
+A099 B9FB
+A09A B9FC
+A09B B9FD
+A09C B9FE
+A09D B9FF
+A0A1 BA00
+A0A2 BA01
+A0A3 BA02
+A0A4 BA03
+A0A5 BA04
+A0A6 BA05
+A0A7 BA06
+A0A8 BA07
+A0A9 BA08
+A0AA BA09
+A0AB BA0A
+A0AC BA0B
+A0AD BA0C
+A0AE BA0D
+A0AF BA0E
+A0B0 BA0F
+A0B1 BA10
+A0B3 BA11
+A0B4 BA12
+A0B5 BA13
+A0B6 BA14
+A0B7 BA15
+A0B8 BA16
+A0B9 BA17
+A0BA BA18
+A0BB BA19
+A0BC BA1A
+A0BD BA1B
+A0C1 BA1C
+A0C2 BA1D
+A0C3 BA1E
+A0C4 BA1F
+A0C5 BA20
+A0C6 BA21
+A0C7 BA22
+A0C8 BA23
+A0C9 BA24
+A0CA BA25
+A0CB BA26
+A0CC BA27
+A0CD BA28
+A0CE BA29
+A0CF BA2A
+A0D0 BA2B
+A0D1 BA2C
+A0D3 BA2D
+A0D4 BA2E
+A0D5 BA2F
+A0D6 BA30
+A0D7 BA31
+A0D8 BA32
+A0D9 BA33
+A0DA BA34
+A0DB BA35
+A0DC BA36
+A0DD BA37
+A0E1 BA38
+A0E2 BA39
+A0E3 BA3A
+A0E4 BA3B
+A0E5 BA3C
+A0E6 BA3D
+A0E7 BA3E
+A0E8 BA3F
+A0E9 BA40
+A0EA BA41
+A0EB BA42
+A0EC BA43
+A0ED BA44
+A0EE BA45
+A0EF BA46
+A0F0 BA47
+A0F1 BA48
+A0F3 BA49
+A0F4 BA4A
+A0F5 BA4B
+A0F6 BA4C
+A0F7 BA4D
+A0F8 BA4E
+A0F9 BA4F
+A0FA BA50
+A0FB BA51
+A0FC BA52
+A0FD BA53
+A141 BA54
+A142 BA55
+A143 BA56
+A144 BA57
+A145 BA58
+A146 BA59
+A147 BA5A
+A148 BA5B
+A149 BA5C
+A14A BA5D
+A14B BA5E
+A14C BA5F
+A14D BA60
+A14E BA61
+A14F BA62
+A150 BA63
+A151 BA64
+A153 BA65
+A154 BA66
+A155 BA67
+A156 BA68
+A157 BA69
+A158 BA6A
+A159 BA6B
+A15A BA6C
+A15B BA6D
+A15C BA6E
+A15D BA6F
+A161 BA70
+A162 BA71
+A163 BA72
+A164 BA73
+A165 BA74
+A166 BA75
+A167 BA76
+A168 BA77
+A169 BA78
+A16A BA79
+A16B BA7A
+A16C BA7B
+A16D BA7C
+A16E BA7D
+A16F BA7E
+A170 BA7F
+A171 BA80
+A173 BA81
+A174 BA82
+A175 BA83
+A176 BA84
+A177 BA85
+A178 BA86
+A179 BA87
+A17A BA88
+A17B BA89
+A17C BA8A
+A17D BA8B
+A181 BA8C
+A182 BA8D
+A183 BA8E
+A184 BA8F
+A185 BA90
+A186 BA91
+A187 BA92
+A188 BA93
+A189 BA94
+A18A BA95
+A18B BA96
+A18C BA97
+A18D BA98
+A18E BA99
+A18F BA9A
+A190 BA9B
+A191 BA9C
+A193 BA9D
+A194 BA9E
+A195 BA9F
+A196 BAA0
+A197 BAA1
+A198 BAA2
+A199 BAA3
+A19A BAA4
+A19B BAA5
+A19C BAA6
+A19D BAA7
+A1A1 BAA8
+A1A2 BAA9
+A1A3 BAAA
+A1A4 BAAB
+A1A5 BAAC
+A1A6 BAAD
+A1A7 BAAE
+A1A8 BAAF
+A1A9 BAB0
+A1AA BAB1
+A1AB BAB2
+A1AC BAB3
+A1AD BAB4
+A1AE BAB5
+A1AF BAB6
+A1B0 BAB7
+A1B1 BAB8
+A1B3 BAB9
+A1B4 BABA
+A1B5 BABB
+A1B6 BABC
+A1B7 BABD
+A1B8 BABE
+A1B9 BABF
+A1BA BAC0
+A1BB BAC1
+A1BC BAC2
+A1BD BAC3
+A1C1 BAC4
+A1C2 BAC5
+A1C3 BAC6
+A1C4 BAC7
+A1C5 BAC8
+A1C6 BAC9
+A1C7 BACA
+A1C8 BACB
+A1C9 BACC
+A1CA BACD
+A1CB BACE
+A1CC BACF
+A1CD BAD0
+A1CE BAD1
+A1CF BAD2
+A1D0 BAD3
+A1D1 BAD4
+A1D3 BAD5
+A1D4 BAD6
+A1D5 BAD7
+A1D6 BAD8
+A1D7 BAD9
+A1D8 BADA
+A1D9 BADB
+A1DA BADC
+A1DB BADD
+A1DC BADE
+A1DD BADF
+A1E1 BAE0
+A1E2 BAE1
+A1E3 BAE2
+A1E4 BAE3
+A1E5 BAE4
+A1E6 BAE5
+A1E7 BAE6
+A1E8 BAE7
+A1E9 BAE8
+A1EA BAE9
+A1EB BAEA
+A1EC BAEB
+A1ED BAEC
+A1EE BAED
+A1EF BAEE
+A1F0 BAEF
+A1F1 BAF0
+A1F3 BAF1
+A1F4 BAF2
+A1F5 BAF3
+A1F6 BAF4
+A1F7 BAF5
+A1F8 BAF6
+A1F9 BAF7
+A1FA BAF8
+A1FB BAF9
+A1FC BAFA
+A1FD BAFB
+A241 BAFC
+A242 BAFD
+A243 BAFE
+A244 BAFF
+A245 BB00
+A246 BB01
+A247 BB02
+A248 BB03
+A249 BB04
+A24A BB05
+A24B BB06
+A24C BB07
+A24D BB08
+A24E BB09
+A24F BB0A
+A250 BB0B
+A251 BB0C
+A253 BB0D
+A254 BB0E
+A255 BB0F
+A256 BB10
+A257 BB11
+A258 BB12
+A259 BB13
+A25A BB14
+A25B BB15
+A25C BB16
+A25D BB17
+A261 BB18
+A262 BB19
+A263 BB1A
+A264 BB1B
+A265 BB1C
+A266 BB1D
+A267 BB1E
+A268 BB1F
+A269 BB20
+A26A BB21
+A26B BB22
+A26C BB23
+A26D BB24
+A26E BB25
+A26F BB26
+A270 BB27
+A271 BB28
+A273 BB29
+A274 BB2A
+A275 BB2B
+A276 BB2C
+A277 BB2D
+A278 BB2E
+A279 BB2F
+A27A BB30
+A27B BB31
+A27C BB32
+A27D BB33
+A281 BB34
+A282 BB35
+A283 BB36
+A284 BB37
+A285 BB38
+A286 BB39
+A287 BB3A
+A288 BB3B
+A289 BB3C
+A28A BB3D
+A28B BB3E
+A28C BB3F
+A28D BB40
+A28E BB41
+A28F BB42
+A290 BB43
+A291 BB44
+A293 BB45
+A294 BB46
+A295 BB47
+A296 BB48
+A297 BB49
+A298 BB4A
+A299 BB4B
+A29A BB4C
+A29B BB4D
+A29C BB4E
+A29D BB4F
+A2A1 BB50
+A2A2 BB51
+A2A3 BB52
+A2A4 BB53
+A2A5 BB54
+A2A6 BB55
+A2A7 BB56
+A2A8 BB57
+A2A9 BB58
+A2AA BB59
+A2AB BB5A
+A2AC BB5B
+A2AD BB5C
+A2AE BB5D
+A2AF BB5E
+A2B0 BB5F
+A2B1 BB60
+A2B3 BB61
+A2B4 BB62
+A2B5 BB63
+A2B6 BB64
+A2B7 BB65
+A2B8 BB66
+A2B9 BB67
+A2BA BB68
+A2BB BB69
+A2BC BB6A
+A2BD BB6B
+A2C1 BB6C
+A2C2 BB6D
+A2C3 BB6E
+A2C4 BB6F
+A2C5 BB70
+A2C6 BB71
+A2C7 BB72
+A2C8 BB73
+A2C9 BB74
+A2CA BB75
+A2CB BB76
+A2CC BB77
+A2CD BB78
+A2CE BB79
+A2CF BB7A
+A2D0 BB7B
+A2D1 BB7C
+A2D3 BB7D
+A2D4 BB7E
+A2D5 BB7F
+A2D6 BB80
+A2D7 BB81
+A2D8 BB82
+A2D9 BB83
+A2DA BB84
+A2DB BB85
+A2DC BB86
+A2DD BB87
+A2E1 BB88
+A2E2 BB89
+A2E3 BB8A
+A2E4 BB8B
+A2E5 BB8C
+A2E6 BB8D
+A2E7 BB8E
+A2E8 BB8F
+A2E9 BB90
+A2EA BB91
+A2EB BB92
+A2EC BB93
+A2ED BB94
+A2EE BB95
+A2EF BB96
+A2F0 BB97
+A2F1 BB98
+A2F3 BB99
+A2F4 BB9A
+A2F5 BB9B
+A2F6 BB9C
+A2F7 BB9D
+A2F8 BB9E
+A2F9 BB9F
+A2FA BBA0
+A2FB BBA1
+A2FC BBA2
+A2FD BBA3
+A341 BBA4
+A342 BBA5
+A343 BBA6
+A344 BBA7
+A345 BBA8
+A346 BBA9
+A347 BBAA
+A348 BBAB
+A349 BBAC
+A34A BBAD
+A34B BBAE
+A34C BBAF
+A34D BBB0
+A34E BBB1
+A34F BBB2
+A350 BBB3
+A351 BBB4
+A353 BBB5
+A354 BBB6
+A355 BBB7
+A356 BBB8
+A357 BBB9
+A358 BBBA
+A359 BBBB
+A35A BBBC
+A35B BBBD
+A35C BBBE
+A35D BBBF
+A361 BBC0
+A362 BBC1
+A363 BBC2
+A364 BBC3
+A365 BBC4
+A366 BBC5
+A367 BBC6
+A368 BBC7
+A369 BBC8
+A36A BBC9
+A36B BBCA
+A36C BBCB
+A36D BBCC
+A36E BBCD
+A36F BBCE
+A370 BBCF
+A371 BBD0
+A373 BBD1
+A374 BBD2
+A375 BBD3
+A376 BBD4
+A377 BBD5
+A378 BBD6
+A379 BBD7
+A37A BBD8
+A37B BBD9
+A37C BBDA
+A37D BBDB
+A381 BBDC
+A382 BBDD
+A383 BBDE
+A384 BBDF
+A385 BBE0
+A386 BBE1
+A387 BBE2
+A388 BBE3
+A389 BBE4
+A38A BBE5
+A38B BBE6
+A38C BBE7
+A38D BBE8
+A38E BBE9
+A38F BBEA
+A390 BBEB
+A391 BBEC
+A393 BBED
+A394 BBEE
+A395 BBEF
+A396 BBF0
+A397 BBF1
+A398 BBF2
+A399 BBF3
+A39A BBF4
+A39B BBF5
+A39C BBF6
+A39D BBF7
+A3A1 BBF8
+A3A2 BBF9
+A3A3 BBFA
+A3A4 BBFB
+A3A5 BBFC
+A3A6 BBFD
+A3A7 BBFE
+A3A8 BBFF
+A3A9 BC00
+A3AA BC01
+A3AB BC02
+A3AC BC03
+A3AD BC04
+A3AE BC05
+A3AF BC06
+A3B0 BC07
+A3B1 BC08
+A3B3 BC09
+A3B4 BC0A
+A3B5 BC0B
+A3B6 BC0C
+A3B7 BC0D
+A3B8 BC0E
+A3B9 BC0F
+A3BA BC10
+A3BB BC11
+A3BC BC12
+A3BD BC13
+A441 3142
+A461 BC14
+A462 BC15
+A463 BC16
+A464 BC17
+A465 BC18
+A466 BC19
+A467 BC1A
+A468 BC1B
+A469 BC1C
+A46A BC1D
+A46B BC1E
+A46C BC1F
+A46D BC20
+A46E BC21
+A46F BC22
+A470 BC23
+A471 BC24
+A473 BC25
+A474 BC26
+A475 BC27
+A476 BC28
+A477 BC29
+A478 BC2A
+A479 BC2B
+A47A BC2C
+A47B BC2D
+A47C BC2E
+A47D BC2F
+A481 BC30
+A482 BC31
+A483 BC32
+A484 BC33
+A485 BC34
+A486 BC35
+A487 BC36
+A488 BC37
+A489 BC38
+A48A BC39
+A48B BC3A
+A48C BC3B
+A48D BC3C
+A48E BC3D
+A48F BC3E
+A490 BC3F
+A491 BC40
+A493 BC41
+A494 BC42
+A495 BC43
+A496 BC44
+A497 BC45
+A498 BC46
+A499 BC47
+A49A BC48
+A49B BC49
+A49C BC4A
+A49D BC4B
+A4A1 BC4C
+A4A2 BC4D
+A4A3 BC4E
+A4A4 BC4F
+A4A5 BC50
+A4A6 BC51
+A4A7 BC52
+A4A8 BC53
+A4A9 BC54
+A4AA BC55
+A4AB BC56
+A4AC BC57
+A4AD BC58
+A4AE BC59
+A4AF BC5A
+A4B0 BC5B
+A4B1 BC5C
+A4B3 BC5D
+A4B4 BC5E
+A4B5 BC5F
+A4B6 BC60
+A4B7 BC61
+A4B8 BC62
+A4B9 BC63
+A4BA BC64
+A4BB BC65
+A4BC BC66
+A4BD BC67
+A4C1 BC68
+A4C2 BC69
+A4C3 BC6A
+A4C4 BC6B
+A4C5 BC6C
+A4C6 BC6D
+A4C7 BC6E
+A4C8 BC6F
+A4C9 BC70
+A4CA BC71
+A4CB BC72
+A4CC BC73
+A4CD BC74
+A4CE BC75
+A4CF BC76
+A4D0 BC77
+A4D1 BC78
+A4D3 BC79
+A4D4 BC7A
+A4D5 BC7B
+A4D6 BC7C
+A4D7 BC7D
+A4D8 BC7E
+A4D9 BC7F
+A4DA BC80
+A4DB BC81
+A4DC BC82
+A4DD BC83
+A4E1 BC84
+A4E2 BC85
+A4E3 BC86
+A4E4 BC87
+A4E5 BC88
+A4E6 BC89
+A4E7 BC8A
+A4E8 BC8B
+A4E9 BC8C
+A4EA BC8D
+A4EB BC8E
+A4EC BC8F
+A4ED BC90
+A4EE BC91
+A4EF BC92
+A4F0 BC93
+A4F1 BC94
+A4F3 BC95
+A4F4 BC96
+A4F5 BC97
+A4F6 BC98
+A4F7 BC99
+A4F8 BC9A
+A4F9 BC9B
+A4FA BC9C
+A4FB BC9D
+A4FC BC9E
+A4FD BC9F
+A541 BCA0
+A542 BCA1
+A543 BCA2
+A544 BCA3
+A545 BCA4
+A546 BCA5
+A547 BCA6
+A548 BCA7
+A549 BCA8
+A54A BCA9
+A54B BCAA
+A54C BCAB
+A54D BCAC
+A54E BCAD
+A54F BCAE
+A550 BCAF
+A551 BCB0
+A553 BCB1
+A554 BCB2
+A555 BCB3
+A556 BCB4
+A557 BCB5
+A558 BCB6
+A559 BCB7
+A55A BCB8
+A55B BCB9
+A55C BCBA
+A55D BCBB
+A561 BCBC
+A562 BCBD
+A563 BCBE
+A564 BCBF
+A565 BCC0
+A566 BCC1
+A567 BCC2
+A568 BCC3
+A569 BCC4
+A56A BCC5
+A56B BCC6
+A56C BCC7
+A56D BCC8
+A56E BCC9
+A56F BCCA
+A570 BCCB
+A571 BCCC
+A573 BCCD
+A574 BCCE
+A575 BCCF
+A576 BCD0
+A577 BCD1
+A578 BCD2
+A579 BCD3
+A57A BCD4
+A57B BCD5
+A57C BCD6
+A57D BCD7
+A581 BCD8
+A582 BCD9
+A583 BCDA
+A584 BCDB
+A585 BCDC
+A586 BCDD
+A587 BCDE
+A588 BCDF
+A589 BCE0
+A58A BCE1
+A58B BCE2
+A58C BCE3
+A58D BCE4
+A58E BCE5
+A58F BCE6
+A590 BCE7
+A591 BCE8
+A593 BCE9
+A594 BCEA
+A595 BCEB
+A596 BCEC
+A597 BCED
+A598 BCEE
+A599 BCEF
+A59A BCF0
+A59B BCF1
+A59C BCF2
+A59D BCF3
+A5A1 BCF4
+A5A2 BCF5
+A5A3 BCF6
+A5A4 BCF7
+A5A5 BCF8
+A5A6 BCF9
+A5A7 BCFA
+A5A8 BCFB
+A5A9 BCFC
+A5AA BCFD
+A5AB BCFE
+A5AC BCFF
+A5AD BD00
+A5AE BD01
+A5AF BD02
+A5B0 BD03
+A5B1 BD04
+A5B3 BD05
+A5B4 BD06
+A5B5 BD07
+A5B6 BD08
+A5B7 BD09
+A5B8 BD0A
+A5B9 BD0B
+A5BA BD0C
+A5BB BD0D
+A5BC BD0E
+A5BD BD0F
+A5C1 BD10
+A5C2 BD11
+A5C3 BD12
+A5C4 BD13
+A5C5 BD14
+A5C6 BD15
+A5C7 BD16
+A5C8 BD17
+A5C9 BD18
+A5CA BD19
+A5CB BD1A
+A5CC BD1B
+A5CD BD1C
+A5CE BD1D
+A5CF BD1E
+A5D0 BD1F
+A5D1 BD20
+A5D3 BD21
+A5D4 BD22
+A5D5 BD23
+A5D6 BD24
+A5D7 BD25
+A5D8 BD26
+A5D9 BD27
+A5DA BD28
+A5DB BD29
+A5DC BD2A
+A5DD BD2B
+A5E1 BD2C
+A5E2 BD2D
+A5E3 BD2E
+A5E4 BD2F
+A5E5 BD30
+A5E6 BD31
+A5E7 BD32
+A5E8 BD33
+A5E9 BD34
+A5EA BD35
+A5EB BD36
+A5EC BD37
+A5ED BD38
+A5EE BD39
+A5EF BD3A
+A5F0 BD3B
+A5F1 BD3C
+A5F3 BD3D
+A5F4 BD3E
+A5F5 BD3F
+A5F6 BD40
+A5F7 BD41
+A5F8 BD42
+A5F9 BD43
+A5FA BD44
+A5FB BD45
+A5FC BD46
+A5FD BD47
+A641 BD48
+A642 BD49
+A643 BD4A
+A644 BD4B
+A645 BD4C
+A646 BD4D
+A647 BD4E
+A648 BD4F
+A649 BD50
+A64A BD51
+A64B BD52
+A64C BD53
+A64D BD54
+A64E BD55
+A64F BD56
+A650 BD57
+A651 BD58
+A653 BD59
+A654 BD5A
+A655 BD5B
+A656 BD5C
+A657 BD5D
+A658 BD5E
+A659 BD5F
+A65A BD60
+A65B BD61
+A65C BD62
+A65D BD63
+A661 BD64
+A662 BD65
+A663 BD66
+A664 BD67
+A665 BD68
+A666 BD69
+A667 BD6A
+A668 BD6B
+A669 BD6C
+A66A BD6D
+A66B BD6E
+A66C BD6F
+A66D BD70
+A66E BD71
+A66F BD72
+A670 BD73
+A671 BD74
+A673 BD75
+A674 BD76
+A675 BD77
+A676 BD78
+A677 BD79
+A678 BD7A
+A679 BD7B
+A67A BD7C
+A67B BD7D
+A67C BD7E
+A67D BD7F
+A681 BD80
+A682 BD81
+A683 BD82
+A684 BD83
+A685 BD84
+A686 BD85
+A687 BD86
+A688 BD87
+A689 BD88
+A68A BD89
+A68B BD8A
+A68C BD8B
+A68D BD8C
+A68E BD8D
+A68F BD8E
+A690 BD8F
+A691 BD90
+A693 BD91
+A694 BD92
+A695 BD93
+A696 BD94
+A697 BD95
+A698 BD96
+A699 BD97
+A69A BD98
+A69B BD99
+A69C BD9A
+A69D BD9B
+A6A1 BD9C
+A6A2 BD9D
+A6A3 BD9E
+A6A4 BD9F
+A6A5 BDA0
+A6A6 BDA1
+A6A7 BDA2
+A6A8 BDA3
+A6A9 BDA4
+A6AA BDA5
+A6AB BDA6
+A6AC BDA7
+A6AD BDA8
+A6AE BDA9
+A6AF BDAA
+A6B0 BDAB
+A6B1 BDAC
+A6B3 BDAD
+A6B4 BDAE
+A6B5 BDAF
+A6B6 BDB0
+A6B7 BDB1
+A6B8 BDB2
+A6B9 BDB3
+A6BA BDB4
+A6BB BDB5
+A6BC BDB6
+A6BD BDB7
+A6C1 BDB8
+A6C2 BDB9
+A6C3 BDBA
+A6C4 BDBB
+A6C5 BDBC
+A6C6 BDBD
+A6C7 BDBE
+A6C8 BDBF
+A6C9 BDC0
+A6CA BDC1
+A6CB BDC2
+A6CC BDC3
+A6CD BDC4
+A6CE BDC5
+A6CF BDC6
+A6D0 BDC7
+A6D1 BDC8
+A6D3 BDC9
+A6D4 BDCA
+A6D5 BDCB
+A6D6 BDCC
+A6D7 BDCD
+A6D8 BDCE
+A6D9 BDCF
+A6DA BDD0
+A6DB BDD1
+A6DC BDD2
+A6DD BDD3
+A6E1 BDD4
+A6E2 BDD5
+A6E3 BDD6
+A6E4 BDD7
+A6E5 BDD8
+A6E6 BDD9
+A6E7 BDDA
+A6E8 BDDB
+A6E9 BDDC
+A6EA BDDD
+A6EB BDDE
+A6EC BDDF
+A6ED BDE0
+A6EE BDE1
+A6EF BDE2
+A6F0 BDE3
+A6F1 BDE4
+A6F3 BDE5
+A6F4 BDE6
+A6F5 BDE7
+A6F6 BDE8
+A6F7 BDE9
+A6F8 BDEA
+A6F9 BDEB
+A6FA BDEC
+A6FB BDED
+A6FC BDEE
+A6FD BDEF
+A741 BDF0
+A742 BDF1
+A743 BDF2
+A744 BDF3
+A745 BDF4
+A746 BDF5
+A747 BDF6
+A748 BDF7
+A749 BDF8
+A74A BDF9
+A74B BDFA
+A74C BDFB
+A74D BDFC
+A74E BDFD
+A74F BDFE
+A750 BDFF
+A751 BE00
+A753 BE01
+A754 BE02
+A755 BE03
+A756 BE04
+A757 BE05
+A758 BE06
+A759 BE07
+A75A BE08
+A75B BE09
+A75C BE0A
+A75D BE0B
+A761 BE0C
+A762 BE0D
+A763 BE0E
+A764 BE0F
+A765 BE10
+A766 BE11
+A767 BE12
+A768 BE13
+A769 BE14
+A76A BE15
+A76B BE16
+A76C BE17
+A76D BE18
+A76E BE19
+A76F BE1A
+A770 BE1B
+A771 BE1C
+A773 BE1D
+A774 BE1E
+A775 BE1F
+A776 BE20
+A777 BE21
+A778 BE22
+A779 BE23
+A77A BE24
+A77B BE25
+A77C BE26
+A77D BE27
+A781 BE28
+A782 BE29
+A783 BE2A
+A784 BE2B
+A785 BE2C
+A786 BE2D
+A787 BE2E
+A788 BE2F
+A789 BE30
+A78A BE31
+A78B BE32
+A78C BE33
+A78D BE34
+A78E BE35
+A78F BE36
+A790 BE37
+A791 BE38
+A793 BE39
+A794 BE3A
+A795 BE3B
+A796 BE3C
+A797 BE3D
+A798 BE3E
+A799 BE3F
+A79A BE40
+A79B BE41
+A79C BE42
+A79D BE43
+A7A1 BE44
+A7A2 BE45
+A7A3 BE46
+A7A4 BE47
+A7A5 BE48
+A7A6 BE49
+A7A7 BE4A
+A7A8 BE4B
+A7A9 BE4C
+A7AA BE4D
+A7AB BE4E
+A7AC BE4F
+A7AD BE50
+A7AE BE51
+A7AF BE52
+A7B0 BE53
+A7B1 BE54
+A7B3 BE55
+A7B4 BE56
+A7B5 BE57
+A7B6 BE58
+A7B7 BE59
+A7B8 BE5A
+A7B9 BE5B
+A7BA BE5C
+A7BB BE5D
+A7BC BE5E
+A7BD BE5F
+A841 3143
+A861 BE60
+A862 BE61
+A863 BE62
+A864 BE63
+A865 BE64
+A866 BE65
+A867 BE66
+A868 BE67
+A869 BE68
+A86A BE69
+A86B BE6A
+A86C BE6B
+A86D BE6C
+A86E BE6D
+A86F BE6E
+A870 BE6F
+A871 BE70
+A873 BE71
+A874 BE72
+A875 BE73
+A876 BE74
+A877 BE75
+A878 BE76
+A879 BE77
+A87A BE78
+A87B BE79
+A87C BE7A
+A87D BE7B
+A881 BE7C
+A882 BE7D
+A883 BE7E
+A884 BE7F
+A885 BE80
+A886 BE81
+A887 BE82
+A888 BE83
+A889 BE84
+A88A BE85
+A88B BE86
+A88C BE87
+A88D BE88
+A88E BE89
+A88F BE8A
+A890 BE8B
+A891 BE8C
+A893 BE8D
+A894 BE8E
+A895 BE8F
+A896 BE90
+A897 BE91
+A898 BE92
+A899 BE93
+A89A BE94
+A89B BE95
+A89C BE96
+A89D BE97
+A8A1 BE98
+A8A2 BE99
+A8A3 BE9A
+A8A4 BE9B
+A8A5 BE9C
+A8A6 BE9D
+A8A7 BE9E
+A8A8 BE9F
+A8A9 BEA0
+A8AA BEA1
+A8AB BEA2
+A8AC BEA3
+A8AD BEA4
+A8AE BEA5
+A8AF BEA6
+A8B0 BEA7
+A8B1 BEA8
+A8B3 BEA9
+A8B4 BEAA
+A8B5 BEAB
+A8B6 BEAC
+A8B7 BEAD
+A8B8 BEAE
+A8B9 BEAF
+A8BA BEB0
+A8BB BEB1
+A8BC BEB2
+A8BD BEB3
+A8C1 BEB4
+A8C2 BEB5
+A8C3 BEB6
+A8C4 BEB7
+A8C5 BEB8
+A8C6 BEB9
+A8C7 BEBA
+A8C8 BEBB
+A8C9 BEBC
+A8CA BEBD
+A8CB BEBE
+A8CC BEBF
+A8CD BEC0
+A8CE BEC1
+A8CF BEC2
+A8D0 BEC3
+A8D1 BEC4
+A8D3 BEC5
+A8D4 BEC6
+A8D5 BEC7
+A8D6 BEC8
+A8D7 BEC9
+A8D8 BECA
+A8D9 BECB
+A8DA BECC
+A8DB BECD
+A8DC BECE
+A8DD BECF
+A8E1 BED0
+A8E2 BED1
+A8E3 BED2
+A8E4 BED3
+A8E5 BED4
+A8E6 BED5
+A8E7 BED6
+A8E8 BED7
+A8E9 BED8
+A8EA BED9
+A8EB BEDA
+A8EC BEDB
+A8ED BEDC
+A8EE BEDD
+A8EF BEDE
+A8F0 BEDF
+A8F1 BEE0
+A8F3 BEE1
+A8F4 BEE2
+A8F5 BEE3
+A8F6 BEE4
+A8F7 BEE5
+A8F8 BEE6
+A8F9 BEE7
+A8FA BEE8
+A8FB BEE9
+A8FC BEEA
+A8FD BEEB
+A941 BEEC
+A942 BEED
+A943 BEEE
+A944 BEEF
+A945 BEF0
+A946 BEF1
+A947 BEF2
+A948 BEF3
+A949 BEF4
+A94A BEF5
+A94B BEF6
+A94C BEF7
+A94D BEF8
+A94E BEF9
+A94F BEFA
+A950 BEFB
+A951 BEFC
+A953 BEFD
+A954 BEFE
+A955 BEFF
+A956 BF00
+A957 BF01
+A958 BF02
+A959 BF03
+A95A BF04
+A95B BF05
+A95C BF06
+A95D BF07
+A961 BF08
+A962 BF09
+A963 BF0A
+A964 BF0B
+A965 BF0C
+A966 BF0D
+A967 BF0E
+A968 BF0F
+A969 BF10
+A96A BF11
+A96B BF12
+A96C BF13
+A96D BF14
+A96E BF15
+A96F BF16
+A970 BF17
+A971 BF18
+A973 BF19
+A974 BF1A
+A975 BF1B
+A976 BF1C
+A977 BF1D
+A978 BF1E
+A979 BF1F
+A97A BF20
+A97B BF21
+A97C BF22
+A97D BF23
+A981 BF24
+A982 BF25
+A983 BF26
+A984 BF27
+A985 BF28
+A986 BF29
+A987 BF2A
+A988 BF2B
+A989 BF2C
+A98A BF2D
+A98B BF2E
+A98C BF2F
+A98D BF30
+A98E BF31
+A98F BF32
+A990 BF33
+A991 BF34
+A993 BF35
+A994 BF36
+A995 BF37
+A996 BF38
+A997 BF39
+A998 BF3A
+A999 BF3B
+A99A BF3C
+A99B BF3D
+A99C BF3E
+A99D BF3F
+A9A1 BF40
+A9A2 BF41
+A9A3 BF42
+A9A4 BF43
+A9A5 BF44
+A9A6 BF45
+A9A7 BF46
+A9A8 BF47
+A9A9 BF48
+A9AA BF49
+A9AB BF4A
+A9AC BF4B
+A9AD BF4C
+A9AE BF4D
+A9AF BF4E
+A9B0 BF4F
+A9B1 BF50
+A9B3 BF51
+A9B4 BF52
+A9B5 BF53
+A9B6 BF54
+A9B7 BF55
+A9B8 BF56
+A9B9 BF57
+A9BA BF58
+A9BB BF59
+A9BC BF5A
+A9BD BF5B
+A9C1 BF5C
+A9C2 BF5D
+A9C3 BF5E
+A9C4 BF5F
+A9C5 BF60
+A9C6 BF61
+A9C7 BF62
+A9C8 BF63
+A9C9 BF64
+A9CA BF65
+A9CB BF66
+A9CC BF67
+A9CD BF68
+A9CE BF69
+A9CF BF6A
+A9D0 BF6B
+A9D1 BF6C
+A9D3 BF6D
+A9D4 BF6E
+A9D5 BF6F
+A9D6 BF70
+A9D7 BF71
+A9D8 BF72
+A9D9 BF73
+A9DA BF74
+A9DB BF75
+A9DC BF76
+A9DD BF77
+A9E1 BF78
+A9E2 BF79
+A9E3 BF7A
+A9E4 BF7B
+A9E5 BF7C
+A9E6 BF7D
+A9E7 BF7E
+A9E8 BF7F
+A9E9 BF80
+A9EA BF81
+A9EB BF82
+A9EC BF83
+A9ED BF84
+A9EE BF85
+A9EF BF86
+A9F0 BF87
+A9F1 BF88
+A9F3 BF89
+A9F4 BF8A
+A9F5 BF8B
+A9F6 BF8C
+A9F7 BF8D
+A9F8 BF8E
+A9F9 BF8F
+A9FA BF90
+A9FB BF91
+A9FC BF92
+A9FD BF93
+AA41 BF94
+AA42 BF95
+AA43 BF96
+AA44 BF97
+AA45 BF98
+AA46 BF99
+AA47 BF9A
+AA48 BF9B
+AA49 BF9C
+AA4A BF9D
+AA4B BF9E
+AA4C BF9F
+AA4D BFA0
+AA4E BFA1
+AA4F BFA2
+AA50 BFA3
+AA51 BFA4
+AA53 BFA5
+AA54 BFA6
+AA55 BFA7
+AA56 BFA8
+AA57 BFA9
+AA58 BFAA
+AA59 BFAB
+AA5A BFAC
+AA5B BFAD
+AA5C BFAE
+AA5D BFAF
+AA61 BFB0
+AA62 BFB1
+AA63 BFB2
+AA64 BFB3
+AA65 BFB4
+AA66 BFB5
+AA67 BFB6
+AA68 BFB7
+AA69 BFB8
+AA6A BFB9
+AA6B BFBA
+AA6C BFBB
+AA6D BFBC
+AA6E BFBD
+AA6F BFBE
+AA70 BFBF
+AA71 BFC0
+AA73 BFC1
+AA74 BFC2
+AA75 BFC3
+AA76 BFC4
+AA77 BFC5
+AA78 BFC6
+AA79 BFC7
+AA7A BFC8
+AA7B BFC9
+AA7C BFCA
+AA7D BFCB
+AA81 BFCC
+AA82 BFCD
+AA83 BFCE
+AA84 BFCF
+AA85 BFD0
+AA86 BFD1
+AA87 BFD2
+AA88 BFD3
+AA89 BFD4
+AA8A BFD5
+AA8B BFD6
+AA8C BFD7
+AA8D BFD8
+AA8E BFD9
+AA8F BFDA
+AA90 BFDB
+AA91 BFDC
+AA93 BFDD
+AA94 BFDE
+AA95 BFDF
+AA96 BFE0
+AA97 BFE1
+AA98 BFE2
+AA99 BFE3
+AA9A BFE4
+AA9B BFE5
+AA9C BFE6
+AA9D BFE7
+AAA1 BFE8
+AAA2 BFE9
+AAA3 BFEA
+AAA4 BFEB
+AAA5 BFEC
+AAA6 BFED
+AAA7 BFEE
+AAA8 BFEF
+AAA9 BFF0
+AAAA BFF1
+AAAB BFF2
+AAAC BFF3
+AAAD BFF4
+AAAE BFF5
+AAAF BFF6
+AAB0 BFF7
+AAB1 BFF8
+AAB3 BFF9
+AAB4 BFFA
+AAB5 BFFB
+AAB6 BFFC
+AAB7 BFFD
+AAB8 BFFE
+AAB9 BFFF
+AABA C000
+AABB C001
+AABC C002
+AABD C003
+AAC1 C004
+AAC2 C005
+AAC3 C006
+AAC4 C007
+AAC5 C008
+AAC6 C009
+AAC7 C00A
+AAC8 C00B
+AAC9 C00C
+AACA C00D
+AACB C00E
+AACC C00F
+AACD C010
+AACE C011
+AACF C012
+AAD0 C013
+AAD1 C014
+AAD3 C015
+AAD4 C016
+AAD5 C017
+AAD6 C018
+AAD7 C019
+AAD8 C01A
+AAD9 C01B
+AADA C01C
+AADB C01D
+AADC C01E
+AADD C01F
+AAE1 C020
+AAE2 C021
+AAE3 C022
+AAE4 C023
+AAE5 C024
+AAE6 C025
+AAE7 C026
+AAE8 C027
+AAE9 C028
+AAEA C029
+AAEB C02A
+AAEC C02B
+AAED C02C
+AAEE C02D
+AAEF C02E
+AAF0 C02F
+AAF1 C030
+AAF3 C031
+AAF4 C032
+AAF5 C033
+AAF6 C034
+AAF7 C035
+AAF8 C036
+AAF9 C037
+AAFA C038
+AAFB C039
+AAFC C03A
+AAFD C03B
+AB41 C03C
+AB42 C03D
+AB43 C03E
+AB44 C03F
+AB45 C040
+AB46 C041
+AB47 C042
+AB48 C043
+AB49 C044
+AB4A C045
+AB4B C046
+AB4C C047
+AB4D C048
+AB4E C049
+AB4F C04A
+AB50 C04B
+AB51 C04C
+AB53 C04D
+AB54 C04E
+AB55 C04F
+AB56 C050
+AB57 C051
+AB58 C052
+AB59 C053
+AB5A C054
+AB5B C055
+AB5C C056
+AB5D C057
+AB61 C058
+AB62 C059
+AB63 C05A
+AB64 C05B
+AB65 C05C
+AB66 C05D
+AB67 C05E
+AB68 C05F
+AB69 C060
+AB6A C061
+AB6B C062
+AB6C C063
+AB6D C064
+AB6E C065
+AB6F C066
+AB70 C067
+AB71 C068
+AB73 C069
+AB74 C06A
+AB75 C06B
+AB76 C06C
+AB77 C06D
+AB78 C06E
+AB79 C06F
+AB7A C070
+AB7B C071
+AB7C C072
+AB7D C073
+AB81 C074
+AB82 C075
+AB83 C076
+AB84 C077
+AB85 C078
+AB86 C079
+AB87 C07A
+AB88 C07B
+AB89 C07C
+AB8A C07D
+AB8B C07E
+AB8C C07F
+AB8D C080
+AB8E C081
+AB8F C082
+AB90 C083
+AB91 C084
+AB93 C085
+AB94 C086
+AB95 C087
+AB96 C088
+AB97 C089
+AB98 C08A
+AB99 C08B
+AB9A C08C
+AB9B C08D
+AB9C C08E
+AB9D C08F
+ABA1 C090
+ABA2 C091
+ABA3 C092
+ABA4 C093
+ABA5 C094
+ABA6 C095
+ABA7 C096
+ABA8 C097
+ABA9 C098
+ABAA C099
+ABAB C09A
+ABAC C09B
+ABAD C09C
+ABAE C09D
+ABAF C09E
+ABB0 C09F
+ABB1 C0A0
+ABB3 C0A1
+ABB4 C0A2
+ABB5 C0A3
+ABB6 C0A4
+ABB7 C0A5
+ABB8 C0A6
+ABB9 C0A7
+ABBA C0A8
+ABBB C0A9
+ABBC C0AA
+ABBD C0AB
+AC41 3145
+AC61 C0AC
+AC62 C0AD
+AC63 C0AE
+AC64 C0AF
+AC65 C0B0
+AC66 C0B1
+AC67 C0B2
+AC68 C0B3
+AC69 C0B4
+AC6A C0B5
+AC6B C0B6
+AC6C C0B7
+AC6D C0B8
+AC6E C0B9
+AC6F C0BA
+AC70 C0BB
+AC71 C0BC
+AC73 C0BD
+AC74 C0BE
+AC75 C0BF
+AC76 C0C0
+AC77 C0C1
+AC78 C0C2
+AC79 C0C3
+AC7A C0C4
+AC7B C0C5
+AC7C C0C6
+AC7D C0C7
+AC81 C0C8
+AC82 C0C9
+AC83 C0CA
+AC84 C0CB
+AC85 C0CC
+AC86 C0CD
+AC87 C0CE
+AC88 C0CF
+AC89 C0D0
+AC8A C0D1
+AC8B C0D2
+AC8C C0D3
+AC8D C0D4
+AC8E C0D5
+AC8F C0D6
+AC90 C0D7
+AC91 C0D8
+AC93 C0D9
+AC94 C0DA
+AC95 C0DB
+AC96 C0DC
+AC97 C0DD
+AC98 C0DE
+AC99 C0DF
+AC9A C0E0
+AC9B C0E1
+AC9C C0E2
+AC9D C0E3
+ACA1 C0E4
+ACA2 C0E5
+ACA3 C0E6
+ACA4 C0E7
+ACA5 C0E8
+ACA6 C0E9
+ACA7 C0EA
+ACA8 C0EB
+ACA9 C0EC
+ACAA C0ED
+ACAB C0EE
+ACAC C0EF
+ACAD C0F0
+ACAE C0F1
+ACAF C0F2
+ACB0 C0F3
+ACB1 C0F4
+ACB3 C0F5
+ACB4 C0F6
+ACB5 C0F7
+ACB6 C0F8
+ACB7 C0F9
+ACB8 C0FA
+ACB9 C0FB
+ACBA C0FC
+ACBB C0FD
+ACBC C0FE
+ACBD C0FF
+ACC1 C100
+ACC2 C101
+ACC3 C102
+ACC4 C103
+ACC5 C104
+ACC6 C105
+ACC7 C106
+ACC8 C107
+ACC9 C108
+ACCA C109
+ACCB C10A
+ACCC C10B
+ACCD C10C
+ACCE C10D
+ACCF C10E
+ACD0 C10F
+ACD1 C110
+ACD3 C111
+ACD4 C112
+ACD5 C113
+ACD6 C114
+ACD7 C115
+ACD8 C116
+ACD9 C117
+ACDA C118
+ACDB C119
+ACDC C11A
+ACDD C11B
+ACE1 C11C
+ACE2 C11D
+ACE3 C11E
+ACE4 C11F
+ACE5 C120
+ACE6 C121
+ACE7 C122
+ACE8 C123
+ACE9 C124
+ACEA C125
+ACEB C126
+ACEC C127
+ACED C128
+ACEE C129
+ACEF C12A
+ACF0 C12B
+ACF1 C12C
+ACF3 C12D
+ACF4 C12E
+ACF5 C12F
+ACF6 C130
+ACF7 C131
+ACF8 C132
+ACF9 C133
+ACFA C134
+ACFB C135
+ACFC C136
+ACFD C137
+AD41 C138
+AD42 C139
+AD43 C13A
+AD44 C13B
+AD45 C13C
+AD46 C13D
+AD47 C13E
+AD48 C13F
+AD49 C140
+AD4A C141
+AD4B C142
+AD4C C143
+AD4D C144
+AD4E C145
+AD4F C146
+AD50 C147
+AD51 C148
+AD53 C149
+AD54 C14A
+AD55 C14B
+AD56 C14C
+AD57 C14D
+AD58 C14E
+AD59 C14F
+AD5A C150
+AD5B C151
+AD5C C152
+AD5D C153
+AD61 C154
+AD62 C155
+AD63 C156
+AD64 C157
+AD65 C158
+AD66 C159
+AD67 C15A
+AD68 C15B
+AD69 C15C
+AD6A C15D
+AD6B C15E
+AD6C C15F
+AD6D C160
+AD6E C161
+AD6F C162
+AD70 C163
+AD71 C164
+AD73 C165
+AD74 C166
+AD75 C167
+AD76 C168
+AD77 C169
+AD78 C16A
+AD79 C16B
+AD7A C16C
+AD7B C16D
+AD7C C16E
+AD7D C16F
+AD81 C170
+AD82 C171
+AD83 C172
+AD84 C173
+AD85 C174
+AD86 C175
+AD87 C176
+AD88 C177
+AD89 C178
+AD8A C179
+AD8B C17A
+AD8C C17B
+AD8D C17C
+AD8E C17D
+AD8F C17E
+AD90 C17F
+AD91 C180
+AD93 C181
+AD94 C182
+AD95 C183
+AD96 C184
+AD97 C185
+AD98 C186
+AD99 C187
+AD9A C188
+AD9B C189
+AD9C C18A
+AD9D C18B
+ADA1 C18C
+ADA2 C18D
+ADA3 C18E
+ADA4 C18F
+ADA5 C190
+ADA6 C191
+ADA7 C192
+ADA8 C193
+ADA9 C194
+ADAA C195
+ADAB C196
+ADAC C197
+ADAD C198
+ADAE C199
+ADAF C19A
+ADB0 C19B
+ADB1 C19C
+ADB3 C19D
+ADB4 C19E
+ADB5 C19F
+ADB6 C1A0
+ADB7 C1A1
+ADB8 C1A2
+ADB9 C1A3
+ADBA C1A4
+ADBB C1A5
+ADBC C1A6
+ADBD C1A7
+ADC1 C1A8
+ADC2 C1A9
+ADC3 C1AA
+ADC4 C1AB
+ADC5 C1AC
+ADC6 C1AD
+ADC7 C1AE
+ADC8 C1AF
+ADC9 C1B0
+ADCA C1B1
+ADCB C1B2
+ADCC C1B3
+ADCD C1B4
+ADCE C1B5
+ADCF C1B6
+ADD0 C1B7
+ADD1 C1B8
+ADD3 C1B9
+ADD4 C1BA
+ADD5 C1BB
+ADD6 C1BC
+ADD7 C1BD
+ADD8 C1BE
+ADD9 C1BF
+ADDA C1C0
+ADDB C1C1
+ADDC C1C2
+ADDD C1C3
+ADE1 C1C4
+ADE2 C1C5
+ADE3 C1C6
+ADE4 C1C7
+ADE5 C1C8
+ADE6 C1C9
+ADE7 C1CA
+ADE8 C1CB
+ADE9 C1CC
+ADEA C1CD
+ADEB C1CE
+ADEC C1CF
+ADED C1D0
+ADEE C1D1
+ADEF C1D2
+ADF0 C1D3
+ADF1 C1D4
+ADF3 C1D5
+ADF4 C1D6
+ADF5 C1D7
+ADF6 C1D8
+ADF7 C1D9
+ADF8 C1DA
+ADF9 C1DB
+ADFA C1DC
+ADFB C1DD
+ADFC C1DE
+ADFD C1DF
+AE41 C1E0
+AE42 C1E1
+AE43 C1E2
+AE44 C1E3
+AE45 C1E4
+AE46 C1E5
+AE47 C1E6
+AE48 C1E7
+AE49 C1E8
+AE4A C1E9
+AE4B C1EA
+AE4C C1EB
+AE4D C1EC
+AE4E C1ED
+AE4F C1EE
+AE50 C1EF
+AE51 C1F0
+AE53 C1F1
+AE54 C1F2
+AE55 C1F3
+AE56 C1F4
+AE57 C1F5
+AE58 C1F6
+AE59 C1F7
+AE5A C1F8
+AE5B C1F9
+AE5C C1FA
+AE5D C1FB
+AE61 C1FC
+AE62 C1FD
+AE63 C1FE
+AE64 C1FF
+AE65 C200
+AE66 C201
+AE67 C202
+AE68 C203
+AE69 C204
+AE6A C205
+AE6B C206
+AE6C C207
+AE6D C208
+AE6E C209
+AE6F C20A
+AE70 C20B
+AE71 C20C
+AE73 C20D
+AE74 C20E
+AE75 C20F
+AE76 C210
+AE77 C211
+AE78 C212
+AE79 C213
+AE7A C214
+AE7B C215
+AE7C C216
+AE7D C217
+AE81 C218
+AE82 C219
+AE83 C21A
+AE84 C21B
+AE85 C21C
+AE86 C21D
+AE87 C21E
+AE88 C21F
+AE89 C220
+AE8A C221
+AE8B C222
+AE8C C223
+AE8D C224
+AE8E C225
+AE8F C226
+AE90 C227
+AE91 C228
+AE93 C229
+AE94 C22A
+AE95 C22B
+AE96 C22C
+AE97 C22D
+AE98 C22E
+AE99 C22F
+AE9A C230
+AE9B C231
+AE9C C232
+AE9D C233
+AEA1 C234
+AEA2 C235
+AEA3 C236
+AEA4 C237
+AEA5 C238
+AEA6 C239
+AEA7 C23A
+AEA8 C23B
+AEA9 C23C
+AEAA C23D
+AEAB C23E
+AEAC C23F
+AEAD C240
+AEAE C241
+AEAF C242
+AEB0 C243
+AEB1 C244
+AEB3 C245
+AEB4 C246
+AEB5 C247
+AEB6 C248
+AEB7 C249
+AEB8 C24A
+AEB9 C24B
+AEBA C24C
+AEBB C24D
+AEBC C24E
+AEBD C24F
+AEC1 C250
+AEC2 C251
+AEC3 C252
+AEC4 C253
+AEC5 C254
+AEC6 C255
+AEC7 C256
+AEC8 C257
+AEC9 C258
+AECA C259
+AECB C25A
+AECC C25B
+AECD C25C
+AECE C25D
+AECF C25E
+AED0 C25F
+AED1 C260
+AED3 C261
+AED4 C262
+AED5 C263
+AED6 C264
+AED7 C265
+AED8 C266
+AED9 C267
+AEDA C268
+AEDB C269
+AEDC C26A
+AEDD C26B
+AEE1 C26C
+AEE2 C26D
+AEE3 C26E
+AEE4 C26F
+AEE5 C270
+AEE6 C271
+AEE7 C272
+AEE8 C273
+AEE9 C274
+AEEA C275
+AEEB C276
+AEEC C277
+AEED C278
+AEEE C279
+AEEF C27A
+AEF0 C27B
+AEF1 C27C
+AEF3 C27D
+AEF4 C27E
+AEF5 C27F
+AEF6 C280
+AEF7 C281
+AEF8 C282
+AEF9 C283
+AEFA C284
+AEFB C285
+AEFC C286
+AEFD C287
+AF41 C288
+AF42 C289
+AF43 C28A
+AF44 C28B
+AF45 C28C
+AF46 C28D
+AF47 C28E
+AF48 C28F
+AF49 C290
+AF4A C291
+AF4B C292
+AF4C C293
+AF4D C294
+AF4E C295
+AF4F C296
+AF50 C297
+AF51 C298
+AF53 C299
+AF54 C29A
+AF55 C29B
+AF56 C29C
+AF57 C29D
+AF58 C29E
+AF59 C29F
+AF5A C2A0
+AF5B C2A1
+AF5C C2A2
+AF5D C2A3
+AF61 C2A4
+AF62 C2A5
+AF63 C2A6
+AF64 C2A7
+AF65 C2A8
+AF66 C2A9
+AF67 C2AA
+AF68 C2AB
+AF69 C2AC
+AF6A C2AD
+AF6B C2AE
+AF6C C2AF
+AF6D C2B0
+AF6E C2B1
+AF6F C2B2
+AF70 C2B3
+AF71 C2B4
+AF73 C2B5
+AF74 C2B6
+AF75 C2B7
+AF76 C2B8
+AF77 C2B9
+AF78 C2BA
+AF79 C2BB
+AF7A C2BC
+AF7B C2BD
+AF7C C2BE
+AF7D C2BF
+AF81 C2C0
+AF82 C2C1
+AF83 C2C2
+AF84 C2C3
+AF85 C2C4
+AF86 C2C5
+AF87 C2C6
+AF88 C2C7
+AF89 C2C8
+AF8A C2C9
+AF8B C2CA
+AF8C C2CB
+AF8D C2CC
+AF8E C2CD
+AF8F C2CE
+AF90 C2CF
+AF91 C2D0
+AF93 C2D1
+AF94 C2D2
+AF95 C2D3
+AF96 C2D4
+AF97 C2D5
+AF98 C2D6
+AF99 C2D7
+AF9A C2D8
+AF9B C2D9
+AF9C C2DA
+AF9D C2DB
+AFA1 C2DC
+AFA2 C2DD
+AFA3 C2DE
+AFA4 C2DF
+AFA5 C2E0
+AFA6 C2E1
+AFA7 C2E2
+AFA8 C2E3
+AFA9 C2E4
+AFAA C2E5
+AFAB C2E6
+AFAC C2E7
+AFAD C2E8
+AFAE C2E9
+AFAF C2EA
+AFB0 C2EB
+AFB1 C2EC
+AFB3 C2ED
+AFB4 C2EE
+AFB5 C2EF
+AFB6 C2F0
+AFB7 C2F1
+AFB8 C2F2
+AFB9 C2F3
+AFBA C2F4
+AFBB C2F5
+AFBC C2F6
+AFBD C2F7
+B041 3146
+B061 C2F8
+B062 C2F9
+B063 C2FA
+B064 C2FB
+B065 C2FC
+B066 C2FD
+B067 C2FE
+B068 C2FF
+B069 C300
+B06A C301
+B06B C302
+B06C C303
+B06D C304
+B06E C305
+B06F C306
+B070 C307
+B071 C308
+B073 C309
+B074 C30A
+B075 C30B
+B076 C30C
+B077 C30D
+B078 C30E
+B079 C30F
+B07A C310
+B07B C311
+B07C C312
+B07D C313
+B081 C314
+B082 C315
+B083 C316
+B084 C317
+B085 C318
+B086 C319
+B087 C31A
+B088 C31B
+B089 C31C
+B08A C31D
+B08B C31E
+B08C C31F
+B08D C320
+B08E C321
+B08F C322
+B090 C323
+B091 C324
+B093 C325
+B094 C326
+B095 C327
+B096 C328
+B097 C329
+B098 C32A
+B099 C32B
+B09A C32C
+B09B C32D
+B09C C32E
+B09D C32F
+B0A1 C330
+B0A2 C331
+B0A3 C332
+B0A4 C333
+B0A5 C334
+B0A6 C335
+B0A7 C336
+B0A8 C337
+B0A9 C338
+B0AA C339
+B0AB C33A
+B0AC C33B
+B0AD C33C
+B0AE C33D
+B0AF C33E
+B0B0 C33F
+B0B1 C340
+B0B3 C341
+B0B4 C342
+B0B5 C343
+B0B6 C344
+B0B7 C345
+B0B8 C346
+B0B9 C347
+B0BA C348
+B0BB C349
+B0BC C34A
+B0BD C34B
+B0C1 C34C
+B0C2 C34D
+B0C3 C34E
+B0C4 C34F
+B0C5 C350
+B0C6 C351
+B0C7 C352
+B0C8 C353
+B0C9 C354
+B0CA C355
+B0CB C356
+B0CC C357
+B0CD C358
+B0CE C359
+B0CF C35A
+B0D0 C35B
+B0D1 C35C
+B0D3 C35D
+B0D4 C35E
+B0D5 C35F
+B0D6 C360
+B0D7 C361
+B0D8 C362
+B0D9 C363
+B0DA C364
+B0DB C365
+B0DC C366
+B0DD C367
+B0E1 C368
+B0E2 C369
+B0E3 C36A
+B0E4 C36B
+B0E5 C36C
+B0E6 C36D
+B0E7 C36E
+B0E8 C36F
+B0E9 C370
+B0EA C371
+B0EB C372
+B0EC C373
+B0ED C374
+B0EE C375
+B0EF C376
+B0F0 C377
+B0F1 C378
+B0F3 C379
+B0F4 C37A
+B0F5 C37B
+B0F6 C37C
+B0F7 C37D
+B0F8 C37E
+B0F9 C37F
+B0FA C380
+B0FB C381
+B0FC C382
+B0FD C383
+B141 C384
+B142 C385
+B143 C386
+B144 C387
+B145 C388
+B146 C389
+B147 C38A
+B148 C38B
+B149 C38C
+B14A C38D
+B14B C38E
+B14C C38F
+B14D C390
+B14E C391
+B14F C392
+B150 C393
+B151 C394
+B153 C395
+B154 C396
+B155 C397
+B156 C398
+B157 C399
+B158 C39A
+B159 C39B
+B15A C39C
+B15B C39D
+B15C C39E
+B15D C39F
+B161 C3A0
+B162 C3A1
+B163 C3A2
+B164 C3A3
+B165 C3A4
+B166 C3A5
+B167 C3A6
+B168 C3A7
+B169 C3A8
+B16A C3A9
+B16B C3AA
+B16C C3AB
+B16D C3AC
+B16E C3AD
+B16F C3AE
+B170 C3AF
+B171 C3B0
+B173 C3B1
+B174 C3B2
+B175 C3B3
+B176 C3B4
+B177 C3B5
+B178 C3B6
+B179 C3B7
+B17A C3B8
+B17B C3B9
+B17C C3BA
+B17D C3BB
+B181 C3BC
+B182 C3BD
+B183 C3BE
+B184 C3BF
+B185 C3C0
+B186 C3C1
+B187 C3C2
+B188 C3C3
+B189 C3C4
+B18A C3C5
+B18B C3C6
+B18C C3C7
+B18D C3C8
+B18E C3C9
+B18F C3CA
+B190 C3CB
+B191 C3CC
+B193 C3CD
+B194 C3CE
+B195 C3CF
+B196 C3D0
+B197 C3D1
+B198 C3D2
+B199 C3D3
+B19A C3D4
+B19B C3D5
+B19C C3D6
+B19D C3D7
+B1A1 C3D8
+B1A2 C3D9
+B1A3 C3DA
+B1A4 C3DB
+B1A5 C3DC
+B1A6 C3DD
+B1A7 C3DE
+B1A8 C3DF
+B1A9 C3E0
+B1AA C3E1
+B1AB C3E2
+B1AC C3E3
+B1AD C3E4
+B1AE C3E5
+B1AF C3E6
+B1B0 C3E7
+B1B1 C3E8
+B1B3 C3E9
+B1B4 C3EA
+B1B5 C3EB
+B1B6 C3EC
+B1B7 C3ED
+B1B8 C3EE
+B1B9 C3EF
+B1BA C3F0
+B1BB C3F1
+B1BC C3F2
+B1BD C3F3
+B1C1 C3F4
+B1C2 C3F5
+B1C3 C3F6
+B1C4 C3F7
+B1C5 C3F8
+B1C6 C3F9
+B1C7 C3FA
+B1C8 C3FB
+B1C9 C3FC
+B1CA C3FD
+B1CB C3FE
+B1CC C3FF
+B1CD C400
+B1CE C401
+B1CF C402
+B1D0 C403
+B1D1 C404
+B1D3 C405
+B1D4 C406
+B1D5 C407
+B1D6 C408
+B1D7 C409
+B1D8 C40A
+B1D9 C40B
+B1DA C40C
+B1DB C40D
+B1DC C40E
+B1DD C40F
+B1E1 C410
+B1E2 C411
+B1E3 C412
+B1E4 C413
+B1E5 C414
+B1E6 C415
+B1E7 C416
+B1E8 C417
+B1E9 C418
+B1EA C419
+B1EB C41A
+B1EC C41B
+B1ED C41C
+B1EE C41D
+B1EF C41E
+B1F0 C41F
+B1F1 C420
+B1F3 C421
+B1F4 C422
+B1F5 C423
+B1F6 C424
+B1F7 C425
+B1F8 C426
+B1F9 C427
+B1FA C428
+B1FB C429
+B1FC C42A
+B1FD C42B
+B241 C42C
+B242 C42D
+B243 C42E
+B244 C42F
+B245 C430
+B246 C431
+B247 C432
+B248 C433
+B249 C434
+B24A C435
+B24B C436
+B24C C437
+B24D C438
+B24E C439
+B24F C43A
+B250 C43B
+B251 C43C
+B253 C43D
+B254 C43E
+B255 C43F
+B256 C440
+B257 C441
+B258 C442
+B259 C443
+B25A C444
+B25B C445
+B25C C446
+B25D C447
+B261 C448
+B262 C449
+B263 C44A
+B264 C44B
+B265 C44C
+B266 C44D
+B267 C44E
+B268 C44F
+B269 C450
+B26A C451
+B26B C452
+B26C C453
+B26D C454
+B26E C455
+B26F C456
+B270 C457
+B271 C458
+B273 C459
+B274 C45A
+B275 C45B
+B276 C45C
+B277 C45D
+B278 C45E
+B279 C45F
+B27A C460
+B27B C461
+B27C C462
+B27D C463
+B281 C464
+B282 C465
+B283 C466
+B284 C467
+B285 C468
+B286 C469
+B287 C46A
+B288 C46B
+B289 C46C
+B28A C46D
+B28B C46E
+B28C C46F
+B28D C470
+B28E C471
+B28F C472
+B290 C473
+B291 C474
+B293 C475
+B294 C476
+B295 C477
+B296 C478
+B297 C479
+B298 C47A
+B299 C47B
+B29A C47C
+B29B C47D
+B29C C47E
+B29D C47F
+B2A1 C480
+B2A2 C481
+B2A3 C482
+B2A4 C483
+B2A5 C484
+B2A6 C485
+B2A7 C486
+B2A8 C487
+B2A9 C488
+B2AA C489
+B2AB C48A
+B2AC C48B
+B2AD C48C
+B2AE C48D
+B2AF C48E
+B2B0 C48F
+B2B1 C490
+B2B3 C491
+B2B4 C492
+B2B5 C493
+B2B6 C494
+B2B7 C495
+B2B8 C496
+B2B9 C497
+B2BA C498
+B2BB C499
+B2BC C49A
+B2BD C49B
+B2C1 C49C
+B2C2 C49D
+B2C3 C49E
+B2C4 C49F
+B2C5 C4A0
+B2C6 C4A1
+B2C7 C4A2
+B2C8 C4A3
+B2C9 C4A4
+B2CA C4A5
+B2CB C4A6
+B2CC C4A7
+B2CD C4A8
+B2CE C4A9
+B2CF C4AA
+B2D0 C4AB
+B2D1 C4AC
+B2D3 C4AD
+B2D4 C4AE
+B2D5 C4AF
+B2D6 C4B0
+B2D7 C4B1
+B2D8 C4B2
+B2D9 C4B3
+B2DA C4B4
+B2DB C4B5
+B2DC C4B6
+B2DD C4B7
+B2E1 C4B8
+B2E2 C4B9
+B2E3 C4BA
+B2E4 C4BB
+B2E5 C4BC
+B2E6 C4BD
+B2E7 C4BE
+B2E8 C4BF
+B2E9 C4C0
+B2EA C4C1
+B2EB C4C2
+B2EC C4C3
+B2ED C4C4
+B2EE C4C5
+B2EF C4C6
+B2F0 C4C7
+B2F1 C4C8
+B2F3 C4C9
+B2F4 C4CA
+B2F5 C4CB
+B2F6 C4CC
+B2F7 C4CD
+B2F8 C4CE
+B2F9 C4CF
+B2FA C4D0
+B2FB C4D1
+B2FC C4D2
+B2FD C4D3
+B341 C4D4
+B342 C4D5
+B343 C4D6
+B344 C4D7
+B345 C4D8
+B346 C4D9
+B347 C4DA
+B348 C4DB
+B349 C4DC
+B34A C4DD
+B34B C4DE
+B34C C4DF
+B34D C4E0
+B34E C4E1
+B34F C4E2
+B350 C4E3
+B351 C4E4
+B353 C4E5
+B354 C4E6
+B355 C4E7
+B356 C4E8
+B357 C4E9
+B358 C4EA
+B359 C4EB
+B35A C4EC
+B35B C4ED
+B35C C4EE
+B35D C4EF
+B361 C4F0
+B362 C4F1
+B363 C4F2
+B364 C4F3
+B365 C4F4
+B366 C4F5
+B367 C4F6
+B368 C4F7
+B369 C4F8
+B36A C4F9
+B36B C4FA
+B36C C4FB
+B36D C4FC
+B36E C4FD
+B36F C4FE
+B370 C4FF
+B371 C500
+B373 C501
+B374 C502
+B375 C503
+B376 C504
+B377 C505
+B378 C506
+B379 C507
+B37A C508
+B37B C509
+B37C C50A
+B37D C50B
+B381 C50C
+B382 C50D
+B383 C50E
+B384 C50F
+B385 C510
+B386 C511
+B387 C512
+B388 C513
+B389 C514
+B38A C515
+B38B C516
+B38C C517
+B38D C518
+B38E C519
+B38F C51A
+B390 C51B
+B391 C51C
+B393 C51D
+B394 C51E
+B395 C51F
+B396 C520
+B397 C521
+B398 C522
+B399 C523
+B39A C524
+B39B C525
+B39C C526
+B39D C527
+B3A1 C528
+B3A2 C529
+B3A3 C52A
+B3A4 C52B
+B3A5 C52C
+B3A6 C52D
+B3A7 C52E
+B3A8 C52F
+B3A9 C530
+B3AA C531
+B3AB C532
+B3AC C533
+B3AD C534
+B3AE C535
+B3AF C536
+B3B0 C537
+B3B1 C538
+B3B3 C539
+B3B4 C53A
+B3B5 C53B
+B3B6 C53C
+B3B7 C53D
+B3B8 C53E
+B3B9 C53F
+B3BA C540
+B3BB C541
+B3BC C542
+B3BD C543
+B441 3147
+B461 C544
+B462 C545
+B463 C546
+B464 C547
+B465 C548
+B466 C549
+B467 C54A
+B468 C54B
+B469 C54C
+B46A C54D
+B46B C54E
+B46C C54F
+B46D C550
+B46E C551
+B46F C552
+B470 C553
+B471 C554
+B473 C555
+B474 C556
+B475 C557
+B476 C558
+B477 C559
+B478 C55A
+B479 C55B
+B47A C55C
+B47B C55D
+B47C C55E
+B47D C55F
+B481 C560
+B482 C561
+B483 C562
+B484 C563
+B485 C564
+B486 C565
+B487 C566
+B488 C567
+B489 C568
+B48A C569
+B48B C56A
+B48C C56B
+B48D C56C
+B48E C56D
+B48F C56E
+B490 C56F
+B491 C570
+B493 C571
+B494 C572
+B495 C573
+B496 C574
+B497 C575
+B498 C576
+B499 C577
+B49A C578
+B49B C579
+B49C C57A
+B49D C57B
+B4A1 C57C
+B4A2 C57D
+B4A3 C57E
+B4A4 C57F
+B4A5 C580
+B4A6 C581
+B4A7 C582
+B4A8 C583
+B4A9 C584
+B4AA C585
+B4AB C586
+B4AC C587
+B4AD C588
+B4AE C589
+B4AF C58A
+B4B0 C58B
+B4B1 C58C
+B4B3 C58D
+B4B4 C58E
+B4B5 C58F
+B4B6 C590
+B4B7 C591
+B4B8 C592
+B4B9 C593
+B4BA C594
+B4BB C595
+B4BC C596
+B4BD C597
+B4C1 C598
+B4C2 C599
+B4C3 C59A
+B4C4 C59B
+B4C5 C59C
+B4C6 C59D
+B4C7 C59E
+B4C8 C59F
+B4C9 C5A0
+B4CA C5A1
+B4CB C5A2
+B4CC C5A3
+B4CD C5A4
+B4CE C5A5
+B4CF C5A6
+B4D0 C5A7
+B4D1 C5A8
+B4D3 C5A9
+B4D4 C5AA
+B4D5 C5AB
+B4D6 C5AC
+B4D7 C5AD
+B4D8 C5AE
+B4D9 C5AF
+B4DA C5B0
+B4DB C5B1
+B4DC C5B2
+B4DD C5B3
+B4E1 C5B4
+B4E2 C5B5
+B4E3 C5B6
+B4E4 C5B7
+B4E5 C5B8
+B4E6 C5B9
+B4E7 C5BA
+B4E8 C5BB
+B4E9 C5BC
+B4EA C5BD
+B4EB C5BE
+B4EC C5BF
+B4ED C5C0
+B4EE C5C1
+B4EF C5C2
+B4F0 C5C3
+B4F1 C5C4
+B4F3 C5C5
+B4F4 C5C6
+B4F5 C5C7
+B4F6 C5C8
+B4F7 C5C9
+B4F8 C5CA
+B4F9 C5CB
+B4FA C5CC
+B4FB C5CD
+B4FC C5CE
+B4FD C5CF
+B541 C5D0
+B542 C5D1
+B543 C5D2
+B544 C5D3
+B545 C5D4
+B546 C5D5
+B547 C5D6
+B548 C5D7
+B549 C5D8
+B54A C5D9
+B54B C5DA
+B54C C5DB
+B54D C5DC
+B54E C5DD
+B54F C5DE
+B550 C5DF
+B551 C5E0
+B553 C5E1
+B554 C5E2
+B555 C5E3
+B556 C5E4
+B557 C5E5
+B558 C5E6
+B559 C5E7
+B55A C5E8
+B55B C5E9
+B55C C5EA
+B55D C5EB
+B561 C5EC
+B562 C5ED
+B563 C5EE
+B564 C5EF
+B565 C5F0
+B566 C5F1
+B567 C5F2
+B568 C5F3
+B569 C5F4
+B56A C5F5
+B56B C5F6
+B56C C5F7
+B56D C5F8
+B56E C5F9
+B56F C5FA
+B570 C5FB
+B571 C5FC
+B573 C5FD
+B574 C5FE
+B575 C5FF
+B576 C600
+B577 C601
+B578 C602
+B579 C603
+B57A C604
+B57B C605
+B57C C606
+B57D C607
+B581 C608
+B582 C609
+B583 C60A
+B584 C60B
+B585 C60C
+B586 C60D
+B587 C60E
+B588 C60F
+B589 C610
+B58A C611
+B58B C612
+B58C C613
+B58D C614
+B58E C615
+B58F C616
+B590 C617
+B591 C618
+B593 C619
+B594 C61A
+B595 C61B
+B596 C61C
+B597 C61D
+B598 C61E
+B599 C61F
+B59A C620
+B59B C621
+B59C C622
+B59D C623
+B5A1 C624
+B5A2 C625
+B5A3 C626
+B5A4 C627
+B5A5 C628
+B5A6 C629
+B5A7 C62A
+B5A8 C62B
+B5A9 C62C
+B5AA C62D
+B5AB C62E
+B5AC C62F
+B5AD C630
+B5AE C631
+B5AF C632
+B5B0 C633
+B5B1 C634
+B5B3 C635
+B5B4 C636
+B5B5 C637
+B5B6 C638
+B5B7 C639
+B5B8 C63A
+B5B9 C63B
+B5BA C63C
+B5BB C63D
+B5BC C63E
+B5BD C63F
+B5C1 C640
+B5C2 C641
+B5C3 C642
+B5C4 C643
+B5C5 C644
+B5C6 C645
+B5C7 C646
+B5C8 C647
+B5C9 C648
+B5CA C649
+B5CB C64A
+B5CC C64B
+B5CD C64C
+B5CE C64D
+B5CF C64E
+B5D0 C64F
+B5D1 C650
+B5D3 C651
+B5D4 C652
+B5D5 C653
+B5D6 C654
+B5D7 C655
+B5D8 C656
+B5D9 C657
+B5DA C658
+B5DB C659
+B5DC C65A
+B5DD C65B
+B5E1 C65C
+B5E2 C65D
+B5E3 C65E
+B5E4 C65F
+B5E5 C660
+B5E6 C661
+B5E7 C662
+B5E8 C663
+B5E9 C664
+B5EA C665
+B5EB C666
+B5EC C667
+B5ED C668
+B5EE C669
+B5EF C66A
+B5F0 C66B
+B5F1 C66C
+B5F3 C66D
+B5F4 C66E
+B5F5 C66F
+B5F6 C670
+B5F7 C671
+B5F8 C672
+B5F9 C673
+B5FA C674
+B5FB C675
+B5FC C676
+B5FD C677
+B641 C678
+B642 C679
+B643 C67A
+B644 C67B
+B645 C67C
+B646 C67D
+B647 C67E
+B648 C67F
+B649 C680
+B64A C681
+B64B C682
+B64C C683
+B64D C684
+B64E C685
+B64F C686
+B650 C687
+B651 C688
+B653 C689
+B654 C68A
+B655 C68B
+B656 C68C
+B657 C68D
+B658 C68E
+B659 C68F
+B65A C690
+B65B C691
+B65C C692
+B65D C693
+B661 C694
+B662 C695
+B663 C696
+B664 C697
+B665 C698
+B666 C699
+B667 C69A
+B668 C69B
+B669 C69C
+B66A C69D
+B66B C69E
+B66C C69F
+B66D C6A0
+B66E C6A1
+B66F C6A2
+B670 C6A3
+B671 C6A4
+B673 C6A5
+B674 C6A6
+B675 C6A7
+B676 C6A8
+B677 C6A9
+B678 C6AA
+B679 C6AB
+B67A C6AC
+B67B C6AD
+B67C C6AE
+B67D C6AF
+B681 C6B0
+B682 C6B1
+B683 C6B2
+B684 C6B3
+B685 C6B4
+B686 C6B5
+B687 C6B6
+B688 C6B7
+B689 C6B8
+B68A C6B9
+B68B C6BA
+B68C C6BB
+B68D C6BC
+B68E C6BD
+B68F C6BE
+B690 C6BF
+B691 C6C0
+B693 C6C1
+B694 C6C2
+B695 C6C3
+B696 C6C4
+B697 C6C5
+B698 C6C6
+B699 C6C7
+B69A C6C8
+B69B C6C9
+B69C C6CA
+B69D C6CB
+B6A1 C6CC
+B6A2 C6CD
+B6A3 C6CE
+B6A4 C6CF
+B6A5 C6D0
+B6A6 C6D1
+B6A7 C6D2
+B6A8 C6D3
+B6A9 C6D4
+B6AA C6D5
+B6AB C6D6
+B6AC C6D7
+B6AD C6D8
+B6AE C6D9
+B6AF C6DA
+B6B0 C6DB
+B6B1 C6DC
+B6B3 C6DD
+B6B4 C6DE
+B6B5 C6DF
+B6B6 C6E0
+B6B7 C6E1
+B6B8 C6E2
+B6B9 C6E3
+B6BA C6E4
+B6BB C6E5
+B6BC C6E6
+B6BD C6E7
+B6C1 C6E8
+B6C2 C6E9
+B6C3 C6EA
+B6C4 C6EB
+B6C5 C6EC
+B6C6 C6ED
+B6C7 C6EE
+B6C8 C6EF
+B6C9 C6F0
+B6CA C6F1
+B6CB C6F2
+B6CC C6F3
+B6CD C6F4
+B6CE C6F5
+B6CF C6F6
+B6D0 C6F7
+B6D1 C6F8
+B6D3 C6F9
+B6D4 C6FA
+B6D5 C6FB
+B6D6 C6FC
+B6D7 C6FD
+B6D8 C6FE
+B6D9 C6FF
+B6DA C700
+B6DB C701
+B6DC C702
+B6DD C703
+B6E1 C704
+B6E2 C705
+B6E3 C706
+B6E4 C707
+B6E5 C708
+B6E6 C709
+B6E7 C70A
+B6E8 C70B
+B6E9 C70C
+B6EA C70D
+B6EB C70E
+B6EC C70F
+B6ED C710
+B6EE C711
+B6EF C712
+B6F0 C713
+B6F1 C714
+B6F3 C715
+B6F4 C716
+B6F5 C717
+B6F6 C718
+B6F7 C719
+B6F8 C71A
+B6F9 C71B
+B6FA C71C
+B6FB C71D
+B6FC C71E
+B6FD C71F
+B741 C720
+B742 C721
+B743 C722
+B744 C723
+B745 C724
+B746 C725
+B747 C726
+B748 C727
+B749 C728
+B74A C729
+B74B C72A
+B74C C72B
+B74D C72C
+B74E C72D
+B74F C72E
+B750 C72F
+B751 C730
+B753 C731
+B754 C732
+B755 C733
+B756 C734
+B757 C735
+B758 C736
+B759 C737
+B75A C738
+B75B C739
+B75C C73A
+B75D C73B
+B761 C73C
+B762 C73D
+B763 C73E
+B764 C73F
+B765 C740
+B766 C741
+B767 C742
+B768 C743
+B769 C744
+B76A C745
+B76B C746
+B76C C747
+B76D C748
+B76E C749
+B76F C74A
+B770 C74B
+B771 C74C
+B773 C74D
+B774 C74E
+B775 C74F
+B776 C750
+B777 C751
+B778 C752
+B779 C753
+B77A C754
+B77B C755
+B77C C756
+B77D C757
+B781 C758
+B782 C759
+B783 C75A
+B784 C75B
+B785 C75C
+B786 C75D
+B787 C75E
+B788 C75F
+B789 C760
+B78A C761
+B78B C762
+B78C C763
+B78D C764
+B78E C765
+B78F C766
+B790 C767
+B791 C768
+B793 C769
+B794 C76A
+B795 C76B
+B796 C76C
+B797 C76D
+B798 C76E
+B799 C76F
+B79A C770
+B79B C771
+B79C C772
+B79D C773
+B7A1 C774
+B7A2 C775
+B7A3 C776
+B7A4 C777
+B7A5 C778
+B7A6 C779
+B7A7 C77A
+B7A8 C77B
+B7A9 C77C
+B7AA C77D
+B7AB C77E
+B7AC C77F
+B7AD C780
+B7AE C781
+B7AF C782
+B7B0 C783
+B7B1 C784
+B7B3 C785
+B7B4 C786
+B7B5 C787
+B7B6 C788
+B7B7 C789
+B7B8 C78A
+B7B9 C78B
+B7BA C78C
+B7BB C78D
+B7BC C78E
+B7BD C78F
+B841 3148
+B861 C790
+B862 C791
+B863 C792
+B864 C793
+B865 C794
+B866 C795
+B867 C796
+B868 C797
+B869 C798
+B86A C799
+B86B C79A
+B86C C79B
+B86D C79C
+B86E C79D
+B86F C79E
+B870 C79F
+B871 C7A0
+B873 C7A1
+B874 C7A2
+B875 C7A3
+B876 C7A4
+B877 C7A5
+B878 C7A6
+B879 C7A7
+B87A C7A8
+B87B C7A9
+B87C C7AA
+B87D C7AB
+B881 C7AC
+B882 C7AD
+B883 C7AE
+B884 C7AF
+B885 C7B0
+B886 C7B1
+B887 C7B2
+B888 C7B3
+B889 C7B4
+B88A C7B5
+B88B C7B6
+B88C C7B7
+B88D C7B8
+B88E C7B9
+B88F C7BA
+B890 C7BB
+B891 C7BC
+B893 C7BD
+B894 C7BE
+B895 C7BF
+B896 C7C0
+B897 C7C1
+B898 C7C2
+B899 C7C3
+B89A C7C4
+B89B C7C5
+B89C C7C6
+B89D C7C7
+B8A1 C7C8
+B8A2 C7C9
+B8A3 C7CA
+B8A4 C7CB
+B8A5 C7CC
+B8A6 C7CD
+B8A7 C7CE
+B8A8 C7CF
+B8A9 C7D0
+B8AA C7D1
+B8AB C7D2
+B8AC C7D3
+B8AD C7D4
+B8AE C7D5
+B8AF C7D6
+B8B0 C7D7
+B8B1 C7D8
+B8B3 C7D9
+B8B4 C7DA
+B8B5 C7DB
+B8B6 C7DC
+B8B7 C7DD
+B8B8 C7DE
+B8B9 C7DF
+B8BA C7E0
+B8BB C7E1
+B8BC C7E2
+B8BD C7E3
+B8C1 C7E4
+B8C2 C7E5
+B8C3 C7E6
+B8C4 C7E7
+B8C5 C7E8
+B8C6 C7E9
+B8C7 C7EA
+B8C8 C7EB
+B8C9 C7EC
+B8CA C7ED
+B8CB C7EE
+B8CC C7EF
+B8CD C7F0
+B8CE C7F1
+B8CF C7F2
+B8D0 C7F3
+B8D1 C7F4
+B8D3 C7F5
+B8D4 C7F6
+B8D5 C7F7
+B8D6 C7F8
+B8D7 C7F9
+B8D8 C7FA
+B8D9 C7FB
+B8DA C7FC
+B8DB C7FD
+B8DC C7FE
+B8DD C7FF
+B8E1 C800
+B8E2 C801
+B8E3 C802
+B8E4 C803
+B8E5 C804
+B8E6 C805
+B8E7 C806
+B8E8 C807
+B8E9 C808
+B8EA C809
+B8EB C80A
+B8EC C80B
+B8ED C80C
+B8EE C80D
+B8EF C80E
+B8F0 C80F
+B8F1 C810
+B8F3 C811
+B8F4 C812
+B8F5 C813
+B8F6 C814
+B8F7 C815
+B8F8 C816
+B8F9 C817
+B8FA C818
+B8FB C819
+B8FC C81A
+B8FD C81B
+B941 C81C
+B942 C81D
+B943 C81E
+B944 C81F
+B945 C820
+B946 C821
+B947 C822
+B948 C823
+B949 C824
+B94A C825
+B94B C826
+B94C C827
+B94D C828
+B94E C829
+B94F C82A
+B950 C82B
+B951 C82C
+B953 C82D
+B954 C82E
+B955 C82F
+B956 C830
+B957 C831
+B958 C832
+B959 C833
+B95A C834
+B95B C835
+B95C C836
+B95D C837
+B961 C838
+B962 C839
+B963 C83A
+B964 C83B
+B965 C83C
+B966 C83D
+B967 C83E
+B968 C83F
+B969 C840
+B96A C841
+B96B C842
+B96C C843
+B96D C844
+B96E C845
+B96F C846
+B970 C847
+B971 C848
+B973 C849
+B974 C84A
+B975 C84B
+B976 C84C
+B977 C84D
+B978 C84E
+B979 C84F
+B97A C850
+B97B C851
+B97C C852
+B97D C853
+B981 C854
+B982 C855
+B983 C856
+B984 C857
+B985 C858
+B986 C859
+B987 C85A
+B988 C85B
+B989 C85C
+B98A C85D
+B98B C85E
+B98C C85F
+B98D C860
+B98E C861
+B98F C862
+B990 C863
+B991 C864
+B993 C865
+B994 C866
+B995 C867
+B996 C868
+B997 C869
+B998 C86A
+B999 C86B
+B99A C86C
+B99B C86D
+B99C C86E
+B99D C86F
+B9A1 C870
+B9A2 C871
+B9A3 C872
+B9A4 C873
+B9A5 C874
+B9A6 C875
+B9A7 C876
+B9A8 C877
+B9A9 C878
+B9AA C879
+B9AB C87A
+B9AC C87B
+B9AD C87C
+B9AE C87D
+B9AF C87E
+B9B0 C87F
+B9B1 C880
+B9B3 C881
+B9B4 C882
+B9B5 C883
+B9B6 C884
+B9B7 C885
+B9B8 C886
+B9B9 C887
+B9BA C888
+B9BB C889
+B9BC C88A
+B9BD C88B
+B9C1 C88C
+B9C2 C88D
+B9C3 C88E
+B9C4 C88F
+B9C5 C890
+B9C6 C891
+B9C7 C892
+B9C8 C893
+B9C9 C894
+B9CA C895
+B9CB C896
+B9CC C897
+B9CD C898
+B9CE C899
+B9CF C89A
+B9D0 C89B
+B9D1 C89C
+B9D3 C89D
+B9D4 C89E
+B9D5 C89F
+B9D6 C8A0
+B9D7 C8A1
+B9D8 C8A2
+B9D9 C8A3
+B9DA C8A4
+B9DB C8A5
+B9DC C8A6
+B9DD C8A7
+B9E1 C8A8
+B9E2 C8A9
+B9E3 C8AA
+B9E4 C8AB
+B9E5 C8AC
+B9E6 C8AD
+B9E7 C8AE
+B9E8 C8AF
+B9E9 C8B0
+B9EA C8B1
+B9EB C8B2
+B9EC C8B3
+B9ED C8B4
+B9EE C8B5
+B9EF C8B6
+B9F0 C8B7
+B9F1 C8B8
+B9F3 C8B9
+B9F4 C8BA
+B9F5 C8BB
+B9F6 C8BC
+B9F7 C8BD
+B9F8 C8BE
+B9F9 C8BF
+B9FA C8C0
+B9FB C8C1
+B9FC C8C2
+B9FD C8C3
+BA41 C8C4
+BA42 C8C5
+BA43 C8C6
+BA44 C8C7
+BA45 C8C8
+BA46 C8C9
+BA47 C8CA
+BA48 C8CB
+BA49 C8CC
+BA4A C8CD
+BA4B C8CE
+BA4C C8CF
+BA4D C8D0
+BA4E C8D1
+BA4F C8D2
+BA50 C8D3
+BA51 C8D4
+BA53 C8D5
+BA54 C8D6
+BA55 C8D7
+BA56 C8D8
+BA57 C8D9
+BA58 C8DA
+BA59 C8DB
+BA5A C8DC
+BA5B C8DD
+BA5C C8DE
+BA5D C8DF
+BA61 C8E0
+BA62 C8E1
+BA63 C8E2
+BA64 C8E3
+BA65 C8E4
+BA66 C8E5
+BA67 C8E6
+BA68 C8E7
+BA69 C8E8
+BA6A C8E9
+BA6B C8EA
+BA6C C8EB
+BA6D C8EC
+BA6E C8ED
+BA6F C8EE
+BA70 C8EF
+BA71 C8F0
+BA73 C8F1
+BA74 C8F2
+BA75 C8F3
+BA76 C8F4
+BA77 C8F5
+BA78 C8F6
+BA79 C8F7
+BA7A C8F8
+BA7B C8F9
+BA7C C8FA
+BA7D C8FB
+BA81 C8FC
+BA82 C8FD
+BA83 C8FE
+BA84 C8FF
+BA85 C900
+BA86 C901
+BA87 C902
+BA88 C903
+BA89 C904
+BA8A C905
+BA8B C906
+BA8C C907
+BA8D C908
+BA8E C909
+BA8F C90A
+BA90 C90B
+BA91 C90C
+BA93 C90D
+BA94 C90E
+BA95 C90F
+BA96 C910
+BA97 C911
+BA98 C912
+BA99 C913
+BA9A C914
+BA9B C915
+BA9C C916
+BA9D C917
+BAA1 C918
+BAA2 C919
+BAA3 C91A
+BAA4 C91B
+BAA5 C91C
+BAA6 C91D
+BAA7 C91E
+BAA8 C91F
+BAA9 C920
+BAAA C921
+BAAB C922
+BAAC C923
+BAAD C924
+BAAE C925
+BAAF C926
+BAB0 C927
+BAB1 C928
+BAB3 C929
+BAB4 C92A
+BAB5 C92B
+BAB6 C92C
+BAB7 C92D
+BAB8 C92E
+BAB9 C92F
+BABA C930
+BABB C931
+BABC C932
+BABD C933
+BAC1 C934
+BAC2 C935
+BAC3 C936
+BAC4 C937
+BAC5 C938
+BAC6 C939
+BAC7 C93A
+BAC8 C93B
+BAC9 C93C
+BACA C93D
+BACB C93E
+BACC C93F
+BACD C940
+BACE C941
+BACF C942
+BAD0 C943
+BAD1 C944
+BAD3 C945
+BAD4 C946
+BAD5 C947
+BAD6 C948
+BAD7 C949
+BAD8 C94A
+BAD9 C94B
+BADA C94C
+BADB C94D
+BADC C94E
+BADD C94F
+BAE1 C950
+BAE2 C951
+BAE3 C952
+BAE4 C953
+BAE5 C954
+BAE6 C955
+BAE7 C956
+BAE8 C957
+BAE9 C958
+BAEA C959
+BAEB C95A
+BAEC C95B
+BAED C95C
+BAEE C95D
+BAEF C95E
+BAF0 C95F
+BAF1 C960
+BAF3 C961
+BAF4 C962
+BAF5 C963
+BAF6 C964
+BAF7 C965
+BAF8 C966
+BAF9 C967
+BAFA C968
+BAFB C969
+BAFC C96A
+BAFD C96B
+BB41 C96C
+BB42 C96D
+BB43 C96E
+BB44 C96F
+BB45 C970
+BB46 C971
+BB47 C972
+BB48 C973
+BB49 C974
+BB4A C975
+BB4B C976
+BB4C C977
+BB4D C978
+BB4E C979
+BB4F C97A
+BB50 C97B
+BB51 C97C
+BB53 C97D
+BB54 C97E
+BB55 C97F
+BB56 C980
+BB57 C981
+BB58 C982
+BB59 C983
+BB5A C984
+BB5B C985
+BB5C C986
+BB5D C987
+BB61 C988
+BB62 C989
+BB63 C98A
+BB64 C98B
+BB65 C98C
+BB66 C98D
+BB67 C98E
+BB68 C98F
+BB69 C990
+BB6A C991
+BB6B C992
+BB6C C993
+BB6D C994
+BB6E C995
+BB6F C996
+BB70 C997
+BB71 C998
+BB73 C999
+BB74 C99A
+BB75 C99B
+BB76 C99C
+BB77 C99D
+BB78 C99E
+BB79 C99F
+BB7A C9A0
+BB7B C9A1
+BB7C C9A2
+BB7D C9A3
+BB81 C9A4
+BB82 C9A5
+BB83 C9A6
+BB84 C9A7
+BB85 C9A8
+BB86 C9A9
+BB87 C9AA
+BB88 C9AB
+BB89 C9AC
+BB8A C9AD
+BB8B C9AE
+BB8C C9AF
+BB8D C9B0
+BB8E C9B1
+BB8F C9B2
+BB90 C9B3
+BB91 C9B4
+BB93 C9B5
+BB94 C9B6
+BB95 C9B7
+BB96 C9B8
+BB97 C9B9
+BB98 C9BA
+BB99 C9BB
+BB9A C9BC
+BB9B C9BD
+BB9C C9BE
+BB9D C9BF
+BBA1 C9C0
+BBA2 C9C1
+BBA3 C9C2
+BBA4 C9C3
+BBA5 C9C4
+BBA6 C9C5
+BBA7 C9C6
+BBA8 C9C7
+BBA9 C9C8
+BBAA C9C9
+BBAB C9CA
+BBAC C9CB
+BBAD C9CC
+BBAE C9CD
+BBAF C9CE
+BBB0 C9CF
+BBB1 C9D0
+BBB3 C9D1
+BBB4 C9D2
+BBB5 C9D3
+BBB6 C9D4
+BBB7 C9D5
+BBB8 C9D6
+BBB9 C9D7
+BBBA C9D8
+BBBB C9D9
+BBBC C9DA
+BBBD C9DB
+BC41 3149
+BC61 C9DC
+BC62 C9DD
+BC63 C9DE
+BC64 C9DF
+BC65 C9E0
+BC66 C9E1
+BC67 C9E2
+BC68 C9E3
+BC69 C9E4
+BC6A C9E5
+BC6B C9E6
+BC6C C9E7
+BC6D C9E8
+BC6E C9E9
+BC6F C9EA
+BC70 C9EB
+BC71 C9EC
+BC73 C9ED
+BC74 C9EE
+BC75 C9EF
+BC76 C9F0
+BC77 C9F1
+BC78 C9F2
+BC79 C9F3
+BC7A C9F4
+BC7B C9F5
+BC7C C9F6
+BC7D C9F7
+BC81 C9F8
+BC82 C9F9
+BC83 C9FA
+BC84 C9FB
+BC85 C9FC
+BC86 C9FD
+BC87 C9FE
+BC88 C9FF
+BC89 CA00
+BC8A CA01
+BC8B CA02
+BC8C CA03
+BC8D CA04
+BC8E CA05
+BC8F CA06
+BC90 CA07
+BC91 CA08
+BC93 CA09
+BC94 CA0A
+BC95 CA0B
+BC96 CA0C
+BC97 CA0D
+BC98 CA0E
+BC99 CA0F
+BC9A CA10
+BC9B CA11
+BC9C CA12
+BC9D CA13
+BCA1 CA14
+BCA2 CA15
+BCA3 CA16
+BCA4 CA17
+BCA5 CA18
+BCA6 CA19
+BCA7 CA1A
+BCA8 CA1B
+BCA9 CA1C
+BCAA CA1D
+BCAB CA1E
+BCAC CA1F
+BCAD CA20
+BCAE CA21
+BCAF CA22
+BCB0 CA23
+BCB1 CA24
+BCB3 CA25
+BCB4 CA26
+BCB5 CA27
+BCB6 CA28
+BCB7 CA29
+BCB8 CA2A
+BCB9 CA2B
+BCBA CA2C
+BCBB CA2D
+BCBC CA2E
+BCBD CA2F
+BCC1 CA30
+BCC2 CA31
+BCC3 CA32
+BCC4 CA33
+BCC5 CA34
+BCC6 CA35
+BCC7 CA36
+BCC8 CA37
+BCC9 CA38
+BCCA CA39
+BCCB CA3A
+BCCC CA3B
+BCCD CA3C
+BCCE CA3D
+BCCF CA3E
+BCD0 CA3F
+BCD1 CA40
+BCD3 CA41
+BCD4 CA42
+BCD5 CA43
+BCD6 CA44
+BCD7 CA45
+BCD8 CA46
+BCD9 CA47
+BCDA CA48
+BCDB CA49
+BCDC CA4A
+BCDD CA4B
+BCE1 CA4C
+BCE2 CA4D
+BCE3 CA4E
+BCE4 CA4F
+BCE5 CA50
+BCE6 CA51
+BCE7 CA52
+BCE8 CA53
+BCE9 CA54
+BCEA CA55
+BCEB CA56
+BCEC CA57
+BCED CA58
+BCEE CA59
+BCEF CA5A
+BCF0 CA5B
+BCF1 CA5C
+BCF3 CA5D
+BCF4 CA5E
+BCF5 CA5F
+BCF6 CA60
+BCF7 CA61
+BCF8 CA62
+BCF9 CA63
+BCFA CA64
+BCFB CA65
+BCFC CA66
+BCFD CA67
+BD41 CA68
+BD42 CA69
+BD43 CA6A
+BD44 CA6B
+BD45 CA6C
+BD46 CA6D
+BD47 CA6E
+BD48 CA6F
+BD49 CA70
+BD4A CA71
+BD4B CA72
+BD4C CA73
+BD4D CA74
+BD4E CA75
+BD4F CA76
+BD50 CA77
+BD51 CA78
+BD53 CA79
+BD54 CA7A
+BD55 CA7B
+BD56 CA7C
+BD57 CA7D
+BD58 CA7E
+BD59 CA7F
+BD5A CA80
+BD5B CA81
+BD5C CA82
+BD5D CA83
+BD61 CA84
+BD62 CA85
+BD63 CA86
+BD64 CA87
+BD65 CA88
+BD66 CA89
+BD67 CA8A
+BD68 CA8B
+BD69 CA8C
+BD6A CA8D
+BD6B CA8E
+BD6C CA8F
+BD6D CA90
+BD6E CA91
+BD6F CA92
+BD70 CA93
+BD71 CA94
+BD73 CA95
+BD74 CA96
+BD75 CA97
+BD76 CA98
+BD77 CA99
+BD78 CA9A
+BD79 CA9B
+BD7A CA9C
+BD7B CA9D
+BD7C CA9E
+BD7D CA9F
+BD81 CAA0
+BD82 CAA1
+BD83 CAA2
+BD84 CAA3
+BD85 CAA4
+BD86 CAA5
+BD87 CAA6
+BD88 CAA7
+BD89 CAA8
+BD8A CAA9
+BD8B CAAA
+BD8C CAAB
+BD8D CAAC
+BD8E CAAD
+BD8F CAAE
+BD90 CAAF
+BD91 CAB0
+BD93 CAB1
+BD94 CAB2
+BD95 CAB3
+BD96 CAB4
+BD97 CAB5
+BD98 CAB6
+BD99 CAB7
+BD9A CAB8
+BD9B CAB9
+BD9C CABA
+BD9D CABB
+BDA1 CABC
+BDA2 CABD
+BDA3 CABE
+BDA4 CABF
+BDA5 CAC0
+BDA6 CAC1
+BDA7 CAC2
+BDA8 CAC3
+BDA9 CAC4
+BDAA CAC5
+BDAB CAC6
+BDAC CAC7
+BDAD CAC8
+BDAE CAC9
+BDAF CACA
+BDB0 CACB
+BDB1 CACC
+BDB3 CACD
+BDB4 CACE
+BDB5 CACF
+BDB6 CAD0
+BDB7 CAD1
+BDB8 CAD2
+BDB9 CAD3
+BDBA CAD4
+BDBB CAD5
+BDBC CAD6
+BDBD CAD7
+BDC1 CAD8
+BDC2 CAD9
+BDC3 CADA
+BDC4 CADB
+BDC5 CADC
+BDC6 CADD
+BDC7 CADE
+BDC8 CADF
+BDC9 CAE0
+BDCA CAE1
+BDCB CAE2
+BDCC CAE3
+BDCD CAE4
+BDCE CAE5
+BDCF CAE6
+BDD0 CAE7
+BDD1 CAE8
+BDD3 CAE9
+BDD4 CAEA
+BDD5 CAEB
+BDD6 CAEC
+BDD7 CAED
+BDD8 CAEE
+BDD9 CAEF
+BDDA CAF0
+BDDB CAF1
+BDDC CAF2
+BDDD CAF3
+BDE1 CAF4
+BDE2 CAF5
+BDE3 CAF6
+BDE4 CAF7
+BDE5 CAF8
+BDE6 CAF9
+BDE7 CAFA
+BDE8 CAFB
+BDE9 CAFC
+BDEA CAFD
+BDEB CAFE
+BDEC CAFF
+BDED CB00
+BDEE CB01
+BDEF CB02
+BDF0 CB03
+BDF1 CB04
+BDF3 CB05
+BDF4 CB06
+BDF5 CB07
+BDF6 CB08
+BDF7 CB09
+BDF8 CB0A
+BDF9 CB0B
+BDFA CB0C
+BDFB CB0D
+BDFC CB0E
+BDFD CB0F
+BE41 CB10
+BE42 CB11
+BE43 CB12
+BE44 CB13
+BE45 CB14
+BE46 CB15
+BE47 CB16
+BE48 CB17
+BE49 CB18
+BE4A CB19
+BE4B CB1A
+BE4C CB1B
+BE4D CB1C
+BE4E CB1D
+BE4F CB1E
+BE50 CB1F
+BE51 CB20
+BE53 CB21
+BE54 CB22
+BE55 CB23
+BE56 CB24
+BE57 CB25
+BE58 CB26
+BE59 CB27
+BE5A CB28
+BE5B CB29
+BE5C CB2A
+BE5D CB2B
+BE61 CB2C
+BE62 CB2D
+BE63 CB2E
+BE64 CB2F
+BE65 CB30
+BE66 CB31
+BE67 CB32
+BE68 CB33
+BE69 CB34
+BE6A CB35
+BE6B CB36
+BE6C CB37
+BE6D CB38
+BE6E CB39
+BE6F CB3A
+BE70 CB3B
+BE71 CB3C
+BE73 CB3D
+BE74 CB3E
+BE75 CB3F
+BE76 CB40
+BE77 CB41
+BE78 CB42
+BE79 CB43
+BE7A CB44
+BE7B CB45
+BE7C CB46
+BE7D CB47
+BE81 CB48
+BE82 CB49
+BE83 CB4A
+BE84 CB4B
+BE85 CB4C
+BE86 CB4D
+BE87 CB4E
+BE88 CB4F
+BE89 CB50
+BE8A CB51
+BE8B CB52
+BE8C CB53
+BE8D CB54
+BE8E CB55
+BE8F CB56
+BE90 CB57
+BE91 CB58
+BE93 CB59
+BE94 CB5A
+BE95 CB5B
+BE96 CB5C
+BE97 CB5D
+BE98 CB5E
+BE99 CB5F
+BE9A CB60
+BE9B CB61
+BE9C CB62
+BE9D CB63
+BEA1 CB64
+BEA2 CB65
+BEA3 CB66
+BEA4 CB67
+BEA5 CB68
+BEA6 CB69
+BEA7 CB6A
+BEA8 CB6B
+BEA9 CB6C
+BEAA CB6D
+BEAB CB6E
+BEAC CB6F
+BEAD CB70
+BEAE CB71
+BEAF CB72
+BEB0 CB73
+BEB1 CB74
+BEB3 CB75
+BEB4 CB76
+BEB5 CB77
+BEB6 CB78
+BEB7 CB79
+BEB8 CB7A
+BEB9 CB7B
+BEBA CB7C
+BEBB CB7D
+BEBC CB7E
+BEBD CB7F
+BEC1 CB80
+BEC2 CB81
+BEC3 CB82
+BEC4 CB83
+BEC5 CB84
+BEC6 CB85
+BEC7 CB86
+BEC8 CB87
+BEC9 CB88
+BECA CB89
+BECB CB8A
+BECC CB8B
+BECD CB8C
+BECE CB8D
+BECF CB8E
+BED0 CB8F
+BED1 CB90
+BED3 CB91
+BED4 CB92
+BED5 CB93
+BED6 CB94
+BED7 CB95
+BED8 CB96
+BED9 CB97
+BEDA CB98
+BEDB CB99
+BEDC CB9A
+BEDD CB9B
+BEE1 CB9C
+BEE2 CB9D
+BEE3 CB9E
+BEE4 CB9F
+BEE5 CBA0
+BEE6 CBA1
+BEE7 CBA2
+BEE8 CBA3
+BEE9 CBA4
+BEEA CBA5
+BEEB CBA6
+BEEC CBA7
+BEED CBA8
+BEEE CBA9
+BEEF CBAA
+BEF0 CBAB
+BEF1 CBAC
+BEF3 CBAD
+BEF4 CBAE
+BEF5 CBAF
+BEF6 CBB0
+BEF7 CBB1
+BEF8 CBB2
+BEF9 CBB3
+BEFA CBB4
+BEFB CBB5
+BEFC CBB6
+BEFD CBB7
+BF41 CBB8
+BF42 CBB9
+BF43 CBBA
+BF44 CBBB
+BF45 CBBC
+BF46 CBBD
+BF47 CBBE
+BF48 CBBF
+BF49 CBC0
+BF4A CBC1
+BF4B CBC2
+BF4C CBC3
+BF4D CBC4
+BF4E CBC5
+BF4F CBC6
+BF50 CBC7
+BF51 CBC8
+BF53 CBC9
+BF54 CBCA
+BF55 CBCB
+BF56 CBCC
+BF57 CBCD
+BF58 CBCE
+BF59 CBCF
+BF5A CBD0
+BF5B CBD1
+BF5C CBD2
+BF5D CBD3
+BF61 CBD4
+BF62 CBD5
+BF63 CBD6
+BF64 CBD7
+BF65 CBD8
+BF66 CBD9
+BF67 CBDA
+BF68 CBDB
+BF69 CBDC
+BF6A CBDD
+BF6B CBDE
+BF6C CBDF
+BF6D CBE0
+BF6E CBE1
+BF6F CBE2
+BF70 CBE3
+BF71 CBE4
+BF73 CBE5
+BF74 CBE6
+BF75 CBE7
+BF76 CBE8
+BF77 CBE9
+BF78 CBEA
+BF79 CBEB
+BF7A CBEC
+BF7B CBED
+BF7C CBEE
+BF7D CBEF
+BF81 CBF0
+BF82 CBF1
+BF83 CBF2
+BF84 CBF3
+BF85 CBF4
+BF86 CBF5
+BF87 CBF6
+BF88 CBF7
+BF89 CBF8
+BF8A CBF9
+BF8B CBFA
+BF8C CBFB
+BF8D CBFC
+BF8E CBFD
+BF8F CBFE
+BF90 CBFF
+BF91 CC00
+BF93 CC01
+BF94 CC02
+BF95 CC03
+BF96 CC04
+BF97 CC05
+BF98 CC06
+BF99 CC07
+BF9A CC08
+BF9B CC09
+BF9C CC0A
+BF9D CC0B
+BFA1 CC0C
+BFA2 CC0D
+BFA3 CC0E
+BFA4 CC0F
+BFA5 CC10
+BFA6 CC11
+BFA7 CC12
+BFA8 CC13
+BFA9 CC14
+BFAA CC15
+BFAB CC16
+BFAC CC17
+BFAD CC18
+BFAE CC19
+BFAF CC1A
+BFB0 CC1B
+BFB1 CC1C
+BFB3 CC1D
+BFB4 CC1E
+BFB5 CC1F
+BFB6 CC20
+BFB7 CC21
+BFB8 CC22
+BFB9 CC23
+BFBA CC24
+BFBB CC25
+BFBC CC26
+BFBD CC27
+C041 314A
+C061 CC28
+C062 CC29
+C063 CC2A
+C064 CC2B
+C065 CC2C
+C066 CC2D
+C067 CC2E
+C068 CC2F
+C069 CC30
+C06A CC31
+C06B CC32
+C06C CC33
+C06D CC34
+C06E CC35
+C06F CC36
+C070 CC37
+C071 CC38
+C073 CC39
+C074 CC3A
+C075 CC3B
+C076 CC3C
+C077 CC3D
+C078 CC3E
+C079 CC3F
+C07A CC40
+C07B CC41
+C07C CC42
+C07D CC43
+C081 CC44
+C082 CC45
+C083 CC46
+C084 CC47
+C085 CC48
+C086 CC49
+C087 CC4A
+C088 CC4B
+C089 CC4C
+C08A CC4D
+C08B CC4E
+C08C CC4F
+C08D CC50
+C08E CC51
+C08F CC52
+C090 CC53
+C091 CC54
+C093 CC55
+C094 CC56
+C095 CC57
+C096 CC58
+C097 CC59
+C098 CC5A
+C099 CC5B
+C09A CC5C
+C09B CC5D
+C09C CC5E
+C09D CC5F
+C0A1 CC60
+C0A2 CC61
+C0A3 CC62
+C0A4 CC63
+C0A5 CC64
+C0A6 CC65
+C0A7 CC66
+C0A8 CC67
+C0A9 CC68
+C0AA CC69
+C0AB CC6A
+C0AC CC6B
+C0AD CC6C
+C0AE CC6D
+C0AF CC6E
+C0B0 CC6F
+C0B1 CC70
+C0B3 CC71
+C0B4 CC72
+C0B5 CC73
+C0B6 CC74
+C0B7 CC75
+C0B8 CC76
+C0B9 CC77
+C0BA CC78
+C0BB CC79
+C0BC CC7A
+C0BD CC7B
+C0C1 CC7C
+C0C2 CC7D
+C0C3 CC7E
+C0C4 CC7F
+C0C5 CC80
+C0C6 CC81
+C0C7 CC82
+C0C8 CC83
+C0C9 CC84
+C0CA CC85
+C0CB CC86
+C0CC CC87
+C0CD CC88
+C0CE CC89
+C0CF CC8A
+C0D0 CC8B
+C0D1 CC8C
+C0D3 CC8D
+C0D4 CC8E
+C0D5 CC8F
+C0D6 CC90
+C0D7 CC91
+C0D8 CC92
+C0D9 CC93
+C0DA CC94
+C0DB CC95
+C0DC CC96
+C0DD CC97
+C0E1 CC98
+C0E2 CC99
+C0E3 CC9A
+C0E4 CC9B
+C0E5 CC9C
+C0E6 CC9D
+C0E7 CC9E
+C0E8 CC9F
+C0E9 CCA0
+C0EA CCA1
+C0EB CCA2
+C0EC CCA3
+C0ED CCA4
+C0EE CCA5
+C0EF CCA6
+C0F0 CCA7
+C0F1 CCA8
+C0F3 CCA9
+C0F4 CCAA
+C0F5 CCAB
+C0F6 CCAC
+C0F7 CCAD
+C0F8 CCAE
+C0F9 CCAF
+C0FA CCB0
+C0FB CCB1
+C0FC CCB2
+C0FD CCB3
+C141 CCB4
+C142 CCB5
+C143 CCB6
+C144 CCB7
+C145 CCB8
+C146 CCB9
+C147 CCBA
+C148 CCBB
+C149 CCBC
+C14A CCBD
+C14B CCBE
+C14C CCBF
+C14D CCC0
+C14E CCC1
+C14F CCC2
+C150 CCC3
+C151 CCC4
+C153 CCC5
+C154 CCC6
+C155 CCC7
+C156 CCC8
+C157 CCC9
+C158 CCCA
+C159 CCCB
+C15A CCCC
+C15B CCCD
+C15C CCCE
+C15D CCCF
+C161 CCD0
+C162 CCD1
+C163 CCD2
+C164 CCD3
+C165 CCD4
+C166 CCD5
+C167 CCD6
+C168 CCD7
+C169 CCD8
+C16A CCD9
+C16B CCDA
+C16C CCDB
+C16D CCDC
+C16E CCDD
+C16F CCDE
+C170 CCDF
+C171 CCE0
+C173 CCE1
+C174 CCE2
+C175 CCE3
+C176 CCE4
+C177 CCE5
+C178 CCE6
+C179 CCE7
+C17A CCE8
+C17B CCE9
+C17C CCEA
+C17D CCEB
+C181 CCEC
+C182 CCED
+C183 CCEE
+C184 CCEF
+C185 CCF0
+C186 CCF1
+C187 CCF2
+C188 CCF3
+C189 CCF4
+C18A CCF5
+C18B CCF6
+C18C CCF7
+C18D CCF8
+C18E CCF9
+C18F CCFA
+C190 CCFB
+C191 CCFC
+C193 CCFD
+C194 CCFE
+C195 CCFF
+C196 CD00
+C197 CD01
+C198 CD02
+C199 CD03
+C19A CD04
+C19B CD05
+C19C CD06
+C19D CD07
+C1A1 CD08
+C1A2 CD09
+C1A3 CD0A
+C1A4 CD0B
+C1A5 CD0C
+C1A6 CD0D
+C1A7 CD0E
+C1A8 CD0F
+C1A9 CD10
+C1AA CD11
+C1AB CD12
+C1AC CD13
+C1AD CD14
+C1AE CD15
+C1AF CD16
+C1B0 CD17
+C1B1 CD18
+C1B3 CD19
+C1B4 CD1A
+C1B5 CD1B
+C1B6 CD1C
+C1B7 CD1D
+C1B8 CD1E
+C1B9 CD1F
+C1BA CD20
+C1BB CD21
+C1BC CD22
+C1BD CD23
+C1C1 CD24
+C1C2 CD25
+C1C3 CD26
+C1C4 CD27
+C1C5 CD28
+C1C6 CD29
+C1C7 CD2A
+C1C8 CD2B
+C1C9 CD2C
+C1CA CD2D
+C1CB CD2E
+C1CC CD2F
+C1CD CD30
+C1CE CD31
+C1CF CD32
+C1D0 CD33
+C1D1 CD34
+C1D3 CD35
+C1D4 CD36
+C1D5 CD37
+C1D6 CD38
+C1D7 CD39
+C1D8 CD3A
+C1D9 CD3B
+C1DA CD3C
+C1DB CD3D
+C1DC CD3E
+C1DD CD3F
+C1E1 CD40
+C1E2 CD41
+C1E3 CD42
+C1E4 CD43
+C1E5 CD44
+C1E6 CD45
+C1E7 CD46
+C1E8 CD47
+C1E9 CD48
+C1EA CD49
+C1EB CD4A
+C1EC CD4B
+C1ED CD4C
+C1EE CD4D
+C1EF CD4E
+C1F0 CD4F
+C1F1 CD50
+C1F3 CD51
+C1F4 CD52
+C1F5 CD53
+C1F6 CD54
+C1F7 CD55
+C1F8 CD56
+C1F9 CD57
+C1FA CD58
+C1FB CD59
+C1FC CD5A
+C1FD CD5B
+C241 CD5C
+C242 CD5D
+C243 CD5E
+C244 CD5F
+C245 CD60
+C246 CD61
+C247 CD62
+C248 CD63
+C249 CD64
+C24A CD65
+C24B CD66
+C24C CD67
+C24D CD68
+C24E CD69
+C24F CD6A
+C250 CD6B
+C251 CD6C
+C253 CD6D
+C254 CD6E
+C255 CD6F
+C256 CD70
+C257 CD71
+C258 CD72
+C259 CD73
+C25A CD74
+C25B CD75
+C25C CD76
+C25D CD77
+C261 CD78
+C262 CD79
+C263 CD7A
+C264 CD7B
+C265 CD7C
+C266 CD7D
+C267 CD7E
+C268 CD7F
+C269 CD80
+C26A CD81
+C26B CD82
+C26C CD83
+C26D CD84
+C26E CD85
+C26F CD86
+C270 CD87
+C271 CD88
+C273 CD89
+C274 CD8A
+C275 CD8B
+C276 CD8C
+C277 CD8D
+C278 CD8E
+C279 CD8F
+C27A CD90
+C27B CD91
+C27C CD92
+C27D CD93
+C281 CD94
+C282 CD95
+C283 CD96
+C284 CD97
+C285 CD98
+C286 CD99
+C287 CD9A
+C288 CD9B
+C289 CD9C
+C28A CD9D
+C28B CD9E
+C28C CD9F
+C28D CDA0
+C28E CDA1
+C28F CDA2
+C290 CDA3
+C291 CDA4
+C293 CDA5
+C294 CDA6
+C295 CDA7
+C296 CDA8
+C297 CDA9
+C298 CDAA
+C299 CDAB
+C29A CDAC
+C29B CDAD
+C29C CDAE
+C29D CDAF
+C2A1 CDB0
+C2A2 CDB1
+C2A3 CDB2
+C2A4 CDB3
+C2A5 CDB4
+C2A6 CDB5
+C2A7 CDB6
+C2A8 CDB7
+C2A9 CDB8
+C2AA CDB9
+C2AB CDBA
+C2AC CDBB
+C2AD CDBC
+C2AE CDBD
+C2AF CDBE
+C2B0 CDBF
+C2B1 CDC0
+C2B3 CDC1
+C2B4 CDC2
+C2B5 CDC3
+C2B6 CDC4
+C2B7 CDC5
+C2B8 CDC6
+C2B9 CDC7
+C2BA CDC8
+C2BB CDC9
+C2BC CDCA
+C2BD CDCB
+C2C1 CDCC
+C2C2 CDCD
+C2C3 CDCE
+C2C4 CDCF
+C2C5 CDD0
+C2C6 CDD1
+C2C7 CDD2
+C2C8 CDD3
+C2C9 CDD4
+C2CA CDD5
+C2CB CDD6
+C2CC CDD7
+C2CD CDD8
+C2CE CDD9
+C2CF CDDA
+C2D0 CDDB
+C2D1 CDDC
+C2D3 CDDD
+C2D4 CDDE
+C2D5 CDDF
+C2D6 CDE0
+C2D7 CDE1
+C2D8 CDE2
+C2D9 CDE3
+C2DA CDE4
+C2DB CDE5
+C2DC CDE6
+C2DD CDE7
+C2E1 CDE8
+C2E2 CDE9
+C2E3 CDEA
+C2E4 CDEB
+C2E5 CDEC
+C2E6 CDED
+C2E7 CDEE
+C2E8 CDEF
+C2E9 CDF0
+C2EA CDF1
+C2EB CDF2
+C2EC CDF3
+C2ED CDF4
+C2EE CDF5
+C2EF CDF6
+C2F0 CDF7
+C2F1 CDF8
+C2F3 CDF9
+C2F4 CDFA
+C2F5 CDFB
+C2F6 CDFC
+C2F7 CDFD
+C2F8 CDFE
+C2F9 CDFF
+C2FA CE00
+C2FB CE01
+C2FC CE02
+C2FD CE03
+C341 CE04
+C342 CE05
+C343 CE06
+C344 CE07
+C345 CE08
+C346 CE09
+C347 CE0A
+C348 CE0B
+C349 CE0C
+C34A CE0D
+C34B CE0E
+C34C CE0F
+C34D CE10
+C34E CE11
+C34F CE12
+C350 CE13
+C351 CE14
+C353 CE15
+C354 CE16
+C355 CE17
+C356 CE18
+C357 CE19
+C358 CE1A
+C359 CE1B
+C35A CE1C
+C35B CE1D
+C35C CE1E
+C35D CE1F
+C361 CE20
+C362 CE21
+C363 CE22
+C364 CE23
+C365 CE24
+C366 CE25
+C367 CE26
+C368 CE27
+C369 CE28
+C36A CE29
+C36B CE2A
+C36C CE2B
+C36D CE2C
+C36E CE2D
+C36F CE2E
+C370 CE2F
+C371 CE30
+C373 CE31
+C374 CE32
+C375 CE33
+C376 CE34
+C377 CE35
+C378 CE36
+C379 CE37
+C37A CE38
+C37B CE39
+C37C CE3A
+C37D CE3B
+C381 CE3C
+C382 CE3D
+C383 CE3E
+C384 CE3F
+C385 CE40
+C386 CE41
+C387 CE42
+C388 CE43
+C389 CE44
+C38A CE45
+C38B CE46
+C38C CE47
+C38D CE48
+C38E CE49
+C38F CE4A
+C390 CE4B
+C391 CE4C
+C393 CE4D
+C394 CE4E
+C395 CE4F
+C396 CE50
+C397 CE51
+C398 CE52
+C399 CE53
+C39A CE54
+C39B CE55
+C39C CE56
+C39D CE57
+C3A1 CE58
+C3A2 CE59
+C3A3 CE5A
+C3A4 CE5B
+C3A5 CE5C
+C3A6 CE5D
+C3A7 CE5E
+C3A8 CE5F
+C3A9 CE60
+C3AA CE61
+C3AB CE62
+C3AC CE63
+C3AD CE64
+C3AE CE65
+C3AF CE66
+C3B0 CE67
+C3B1 CE68
+C3B3 CE69
+C3B4 CE6A
+C3B5 CE6B
+C3B6 CE6C
+C3B7 CE6D
+C3B8 CE6E
+C3B9 CE6F
+C3BA CE70
+C3BB CE71
+C3BC CE72
+C3BD CE73
+C441 314B
+C461 CE74
+C462 CE75
+C463 CE76
+C464 CE77
+C465 CE78
+C466 CE79
+C467 CE7A
+C468 CE7B
+C469 CE7C
+C46A CE7D
+C46B CE7E
+C46C CE7F
+C46D CE80
+C46E CE81
+C46F CE82
+C470 CE83
+C471 CE84
+C473 CE85
+C474 CE86
+C475 CE87
+C476 CE88
+C477 CE89
+C478 CE8A
+C479 CE8B
+C47A CE8C
+C47B CE8D
+C47C CE8E
+C47D CE8F
+C481 CE90
+C482 CE91
+C483 CE92
+C484 CE93
+C485 CE94
+C486 CE95
+C487 CE96
+C488 CE97
+C489 CE98
+C48A CE99
+C48B CE9A
+C48C CE9B
+C48D CE9C
+C48E CE9D
+C48F CE9E
+C490 CE9F
+C491 CEA0
+C493 CEA1
+C494 CEA2
+C495 CEA3
+C496 CEA4
+C497 CEA5
+C498 CEA6
+C499 CEA7
+C49A CEA8
+C49B CEA9
+C49C CEAA
+C49D CEAB
+C4A1 CEAC
+C4A2 CEAD
+C4A3 CEAE
+C4A4 CEAF
+C4A5 CEB0
+C4A6 CEB1
+C4A7 CEB2
+C4A8 CEB3
+C4A9 CEB4
+C4AA CEB5
+C4AB CEB6
+C4AC CEB7
+C4AD CEB8
+C4AE CEB9
+C4AF CEBA
+C4B0 CEBB
+C4B1 CEBC
+C4B3 CEBD
+C4B4 CEBE
+C4B5 CEBF
+C4B6 CEC0
+C4B7 CEC1
+C4B8 CEC2
+C4B9 CEC3
+C4BA CEC4
+C4BB CEC5
+C4BC CEC6
+C4BD CEC7
+C4C1 CEC8
+C4C2 CEC9
+C4C3 CECA
+C4C4 CECB
+C4C5 CECC
+C4C6 CECD
+C4C7 CECE
+C4C8 CECF
+C4C9 CED0
+C4CA CED1
+C4CB CED2
+C4CC CED3
+C4CD CED4
+C4CE CED5
+C4CF CED6
+C4D0 CED7
+C4D1 CED8
+C4D3 CED9
+C4D4 CEDA
+C4D5 CEDB
+C4D6 CEDC
+C4D7 CEDD
+C4D8 CEDE
+C4D9 CEDF
+C4DA CEE0
+C4DB CEE1
+C4DC CEE2
+C4DD CEE3
+C4E1 CEE4
+C4E2 CEE5
+C4E3 CEE6
+C4E4 CEE7
+C4E5 CEE8
+C4E6 CEE9
+C4E7 CEEA
+C4E8 CEEB
+C4E9 CEEC
+C4EA CEED
+C4EB CEEE
+C4EC CEEF
+C4ED CEF0
+C4EE CEF1
+C4EF CEF2
+C4F0 CEF3
+C4F1 CEF4
+C4F3 CEF5
+C4F4 CEF6
+C4F5 CEF7
+C4F6 CEF8
+C4F7 CEF9
+C4F8 CEFA
+C4F9 CEFB
+C4FA CEFC
+C4FB CEFD
+C4FC CEFE
+C4FD CEFF
+C541 CF00
+C542 CF01
+C543 CF02
+C544 CF03
+C545 CF04
+C546 CF05
+C547 CF06
+C548 CF07
+C549 CF08
+C54A CF09
+C54B CF0A
+C54C CF0B
+C54D CF0C
+C54E CF0D
+C54F CF0E
+C550 CF0F
+C551 CF10
+C553 CF11
+C554 CF12
+C555 CF13
+C556 CF14
+C557 CF15
+C558 CF16
+C559 CF17
+C55A CF18
+C55B CF19
+C55C CF1A
+C55D CF1B
+C561 CF1C
+C562 CF1D
+C563 CF1E
+C564 CF1F
+C565 CF20
+C566 CF21
+C567 CF22
+C568 CF23
+C569 CF24
+C56A CF25
+C56B CF26
+C56C CF27
+C56D CF28
+C56E CF29
+C56F CF2A
+C570 CF2B
+C571 CF2C
+C573 CF2D
+C574 CF2E
+C575 CF2F
+C576 CF30
+C577 CF31
+C578 CF32
+C579 CF33
+C57A CF34
+C57B CF35
+C57C CF36
+C57D CF37
+C581 CF38
+C582 CF39
+C583 CF3A
+C584 CF3B
+C585 CF3C
+C586 CF3D
+C587 CF3E
+C588 CF3F
+C589 CF40
+C58A CF41
+C58B CF42
+C58C CF43
+C58D CF44
+C58E CF45
+C58F CF46
+C590 CF47
+C591 CF48
+C593 CF49
+C594 CF4A
+C595 CF4B
+C596 CF4C
+C597 CF4D
+C598 CF4E
+C599 CF4F
+C59A CF50
+C59B CF51
+C59C CF52
+C59D CF53
+C5A1 CF54
+C5A2 CF55
+C5A3 CF56
+C5A4 CF57
+C5A5 CF58
+C5A6 CF59
+C5A7 CF5A
+C5A8 CF5B
+C5A9 CF5C
+C5AA CF5D
+C5AB CF5E
+C5AC CF5F
+C5AD CF60
+C5AE CF61
+C5AF CF62
+C5B0 CF63
+C5B1 CF64
+C5B3 CF65
+C5B4 CF66
+C5B5 CF67
+C5B6 CF68
+C5B7 CF69
+C5B8 CF6A
+C5B9 CF6B
+C5BA CF6C
+C5BB CF6D
+C5BC CF6E
+C5BD CF6F
+C5C1 CF70
+C5C2 CF71
+C5C3 CF72
+C5C4 CF73
+C5C5 CF74
+C5C6 CF75
+C5C7 CF76
+C5C8 CF77
+C5C9 CF78
+C5CA CF79
+C5CB CF7A
+C5CC CF7B
+C5CD CF7C
+C5CE CF7D
+C5CF CF7E
+C5D0 CF7F
+C5D1 CF80
+C5D3 CF81
+C5D4 CF82
+C5D5 CF83
+C5D6 CF84
+C5D7 CF85
+C5D8 CF86
+C5D9 CF87
+C5DA CF88
+C5DB CF89
+C5DC CF8A
+C5DD CF8B
+C5E1 CF8C
+C5E2 CF8D
+C5E3 CF8E
+C5E4 CF8F
+C5E5 CF90
+C5E6 CF91
+C5E7 CF92
+C5E8 CF93
+C5E9 CF94
+C5EA CF95
+C5EB CF96
+C5EC CF97
+C5ED CF98
+C5EE CF99
+C5EF CF9A
+C5F0 CF9B
+C5F1 CF9C
+C5F3 CF9D
+C5F4 CF9E
+C5F5 CF9F
+C5F6 CFA0
+C5F7 CFA1
+C5F8 CFA2
+C5F9 CFA3
+C5FA CFA4
+C5FB CFA5
+C5FC CFA6
+C5FD CFA7
+C641 CFA8
+C642 CFA9
+C643 CFAA
+C644 CFAB
+C645 CFAC
+C646 CFAD
+C647 CFAE
+C648 CFAF
+C649 CFB0
+C64A CFB1
+C64B CFB2
+C64C CFB3
+C64D CFB4
+C64E CFB5
+C64F CFB6
+C650 CFB7
+C651 CFB8
+C653 CFB9
+C654 CFBA
+C655 CFBB
+C656 CFBC
+C657 CFBD
+C658 CFBE
+C659 CFBF
+C65A CFC0
+C65B CFC1
+C65C CFC2
+C65D CFC3
+C661 CFC4
+C662 CFC5
+C663 CFC6
+C664 CFC7
+C665 CFC8
+C666 CFC9
+C667 CFCA
+C668 CFCB
+C669 CFCC
+C66A CFCD
+C66B CFCE
+C66C CFCF
+C66D CFD0
+C66E CFD1
+C66F CFD2
+C670 CFD3
+C671 CFD4
+C673 CFD5
+C674 CFD6
+C675 CFD7
+C676 CFD8
+C677 CFD9
+C678 CFDA
+C679 CFDB
+C67A CFDC
+C67B CFDD
+C67C CFDE
+C67D CFDF
+C681 CFE0
+C682 CFE1
+C683 CFE2
+C684 CFE3
+C685 CFE4
+C686 CFE5
+C687 CFE6
+C688 CFE7
+C689 CFE8
+C68A CFE9
+C68B CFEA
+C68C CFEB
+C68D CFEC
+C68E CFED
+C68F CFEE
+C690 CFEF
+C691 CFF0
+C693 CFF1
+C694 CFF2
+C695 CFF3
+C696 CFF4
+C697 CFF5
+C698 CFF6
+C699 CFF7
+C69A CFF8
+C69B CFF9
+C69C CFFA
+C69D CFFB
+C6A1 CFFC
+C6A2 CFFD
+C6A3 CFFE
+C6A4 CFFF
+C6A5 D000
+C6A6 D001
+C6A7 D002
+C6A8 D003
+C6A9 D004
+C6AA D005
+C6AB D006
+C6AC D007
+C6AD D008
+C6AE D009
+C6AF D00A
+C6B0 D00B
+C6B1 D00C
+C6B3 D00D
+C6B4 D00E
+C6B5 D00F
+C6B6 D010
+C6B7 D011
+C6B8 D012
+C6B9 D013
+C6BA D014
+C6BB D015
+C6BC D016
+C6BD D017
+C6C1 D018
+C6C2 D019
+C6C3 D01A
+C6C4 D01B
+C6C5 D01C
+C6C6 D01D
+C6C7 D01E
+C6C8 D01F
+C6C9 D020
+C6CA D021
+C6CB D022
+C6CC D023
+C6CD D024
+C6CE D025
+C6CF D026
+C6D0 D027
+C6D1 D028
+C6D3 D029
+C6D4 D02A
+C6D5 D02B
+C6D6 D02C
+C6D7 D02D
+C6D8 D02E
+C6D9 D02F
+C6DA D030
+C6DB D031
+C6DC D032
+C6DD D033
+C6E1 D034
+C6E2 D035
+C6E3 D036
+C6E4 D037
+C6E5 D038
+C6E6 D039
+C6E7 D03A
+C6E8 D03B
+C6E9 D03C
+C6EA D03D
+C6EB D03E
+C6EC D03F
+C6ED D040
+C6EE D041
+C6EF D042
+C6F0 D043
+C6F1 D044
+C6F3 D045
+C6F4 D046
+C6F5 D047
+C6F6 D048
+C6F7 D049
+C6F8 D04A
+C6F9 D04B
+C6FA D04C
+C6FB D04D
+C6FC D04E
+C6FD D04F
+C741 D050
+C742 D051
+C743 D052
+C744 D053
+C745 D054
+C746 D055
+C747 D056
+C748 D057
+C749 D058
+C74A D059
+C74B D05A
+C74C D05B
+C74D D05C
+C74E D05D
+C74F D05E
+C750 D05F
+C751 D060
+C753 D061
+C754 D062
+C755 D063
+C756 D064
+C757 D065
+C758 D066
+C759 D067
+C75A D068
+C75B D069
+C75C D06A
+C75D D06B
+C761 D06C
+C762 D06D
+C763 D06E
+C764 D06F
+C765 D070
+C766 D071
+C767 D072
+C768 D073
+C769 D074
+C76A D075
+C76B D076
+C76C D077
+C76D D078
+C76E D079
+C76F D07A
+C770 D07B
+C771 D07C
+C773 D07D
+C774 D07E
+C775 D07F
+C776 D080
+C777 D081
+C778 D082
+C779 D083
+C77A D084
+C77B D085
+C77C D086
+C77D D087
+C781 D088
+C782 D089
+C783 D08A
+C784 D08B
+C785 D08C
+C786 D08D
+C787 D08E
+C788 D08F
+C789 D090
+C78A D091
+C78B D092
+C78C D093
+C78D D094
+C78E D095
+C78F D096
+C790 D097
+C791 D098
+C793 D099
+C794 D09A
+C795 D09B
+C796 D09C
+C797 D09D
+C798 D09E
+C799 D09F
+C79A D0A0
+C79B D0A1
+C79C D0A2
+C79D D0A3
+C7A1 D0A4
+C7A2 D0A5
+C7A3 D0A6
+C7A4 D0A7
+C7A5 D0A8
+C7A6 D0A9
+C7A7 D0AA
+C7A8 D0AB
+C7A9 D0AC
+C7AA D0AD
+C7AB D0AE
+C7AC D0AF
+C7AD D0B0
+C7AE D0B1
+C7AF D0B2
+C7B0 D0B3
+C7B1 D0B4
+C7B3 D0B5
+C7B4 D0B6
+C7B5 D0B7
+C7B6 D0B8
+C7B7 D0B9
+C7B8 D0BA
+C7B9 D0BB
+C7BA D0BC
+C7BB D0BD
+C7BC D0BE
+C7BD D0BF
+C841 314C
+C861 D0C0
+C862 D0C1
+C863 D0C2
+C864 D0C3
+C865 D0C4
+C866 D0C5
+C867 D0C6
+C868 D0C7
+C869 D0C8
+C86A D0C9
+C86B D0CA
+C86C D0CB
+C86D D0CC
+C86E D0CD
+C86F D0CE
+C870 D0CF
+C871 D0D0
+C873 D0D1
+C874 D0D2
+C875 D0D3
+C876 D0D4
+C877 D0D5
+C878 D0D6
+C879 D0D7
+C87A D0D8
+C87B D0D9
+C87C D0DA
+C87D D0DB
+C881 D0DC
+C882 D0DD
+C883 D0DE
+C884 D0DF
+C885 D0E0
+C886 D0E1
+C887 D0E2
+C888 D0E3
+C889 D0E4
+C88A D0E5
+C88B D0E6
+C88C D0E7
+C88D D0E8
+C88E D0E9
+C88F D0EA
+C890 D0EB
+C891 D0EC
+C893 D0ED
+C894 D0EE
+C895 D0EF
+C896 D0F0
+C897 D0F1
+C898 D0F2
+C899 D0F3
+C89A D0F4
+C89B D0F5
+C89C D0F6
+C89D D0F7
+C8A1 D0F8
+C8A2 D0F9
+C8A3 D0FA
+C8A4 D0FB
+C8A5 D0FC
+C8A6 D0FD
+C8A7 D0FE
+C8A8 D0FF
+C8A9 D100
+C8AA D101
+C8AB D102
+C8AC D103
+C8AD D104
+C8AE D105
+C8AF D106
+C8B0 D107
+C8B1 D108
+C8B3 D109
+C8B4 D10A
+C8B5 D10B
+C8B6 D10C
+C8B7 D10D
+C8B8 D10E
+C8B9 D10F
+C8BA D110
+C8BB D111
+C8BC D112
+C8BD D113
+C8C1 D114
+C8C2 D115
+C8C3 D116
+C8C4 D117
+C8C5 D118
+C8C6 D119
+C8C7 D11A
+C8C8 D11B
+C8C9 D11C
+C8CA D11D
+C8CB D11E
+C8CC D11F
+C8CD D120
+C8CE D121
+C8CF D122
+C8D0 D123
+C8D1 D124
+C8D3 D125
+C8D4 D126
+C8D5 D127
+C8D6 D128
+C8D7 D129
+C8D8 D12A
+C8D9 D12B
+C8DA D12C
+C8DB D12D
+C8DC D12E
+C8DD D12F
+C8E1 D130
+C8E2 D131
+C8E3 D132
+C8E4 D133
+C8E5 D134
+C8E6 D135
+C8E7 D136
+C8E8 D137
+C8E9 D138
+C8EA D139
+C8EB D13A
+C8EC D13B
+C8ED D13C
+C8EE D13D
+C8EF D13E
+C8F0 D13F
+C8F1 D140
+C8F3 D141
+C8F4 D142
+C8F5 D143
+C8F6 D144
+C8F7 D145
+C8F8 D146
+C8F9 D147
+C8FA D148
+C8FB D149
+C8FC D14A
+C8FD D14B
+C941 D14C
+C942 D14D
+C943 D14E
+C944 D14F
+C945 D150
+C946 D151
+C947 D152
+C948 D153
+C949 D154
+C94A D155
+C94B D156
+C94C D157
+C94D D158
+C94E D159
+C94F D15A
+C950 D15B
+C951 D15C
+C953 D15D
+C954 D15E
+C955 D15F
+C956 D160
+C957 D161
+C958 D162
+C959 D163
+C95A D164
+C95B D165
+C95C D166
+C95D D167
+C961 D168
+C962 D169
+C963 D16A
+C964 D16B
+C965 D16C
+C966 D16D
+C967 D16E
+C968 D16F
+C969 D170
+C96A D171
+C96B D172
+C96C D173
+C96D D174
+C96E D175
+C96F D176
+C970 D177
+C971 D178
+C973 D179
+C974 D17A
+C975 D17B
+C976 D17C
+C977 D17D
+C978 D17E
+C979 D17F
+C97A D180
+C97B D181
+C97C D182
+C97D D183
+C981 D184
+C982 D185
+C983 D186
+C984 D187
+C985 D188
+C986 D189
+C987 D18A
+C988 D18B
+C989 D18C
+C98A D18D
+C98B D18E
+C98C D18F
+C98D D190
+C98E D191
+C98F D192
+C990 D193
+C991 D194
+C993 D195
+C994 D196
+C995 D197
+C996 D198
+C997 D199
+C998 D19A
+C999 D19B
+C99A D19C
+C99B D19D
+C99C D19E
+C99D D19F
+C9A1 D1A0
+C9A2 D1A1
+C9A3 D1A2
+C9A4 D1A3
+C9A5 D1A4
+C9A6 D1A5
+C9A7 D1A6
+C9A8 D1A7
+C9A9 D1A8
+C9AA D1A9
+C9AB D1AA
+C9AC D1AB
+C9AD D1AC
+C9AE D1AD
+C9AF D1AE
+C9B0 D1AF
+C9B1 D1B0
+C9B3 D1B1
+C9B4 D1B2
+C9B5 D1B3
+C9B6 D1B4
+C9B7 D1B5
+C9B8 D1B6
+C9B9 D1B7
+C9BA D1B8
+C9BB D1B9
+C9BC D1BA
+C9BD D1BB
+C9C1 D1BC
+C9C2 D1BD
+C9C3 D1BE
+C9C4 D1BF
+C9C5 D1C0
+C9C6 D1C1
+C9C7 D1C2
+C9C8 D1C3
+C9C9 D1C4
+C9CA D1C5
+C9CB D1C6
+C9CC D1C7
+C9CD D1C8
+C9CE D1C9
+C9CF D1CA
+C9D0 D1CB
+C9D1 D1CC
+C9D3 D1CD
+C9D4 D1CE
+C9D5 D1CF
+C9D6 D1D0
+C9D7 D1D1
+C9D8 D1D2
+C9D9 D1D3
+C9DA D1D4
+C9DB D1D5
+C9DC D1D6
+C9DD D1D7
+C9E1 D1D8
+C9E2 D1D9
+C9E3 D1DA
+C9E4 D1DB
+C9E5 D1DC
+C9E6 D1DD
+C9E7 D1DE
+C9E8 D1DF
+C9E9 D1E0
+C9EA D1E1
+C9EB D1E2
+C9EC D1E3
+C9ED D1E4
+C9EE D1E5
+C9EF D1E6
+C9F0 D1E7
+C9F1 D1E8
+C9F3 D1E9
+C9F4 D1EA
+C9F5 D1EB
+C9F6 D1EC
+C9F7 D1ED
+C9F8 D1EE
+C9F9 D1EF
+C9FA D1F0
+C9FB D1F1
+C9FC D1F2
+C9FD D1F3
+CA41 D1F4
+CA42 D1F5
+CA43 D1F6
+CA44 D1F7
+CA45 D1F8
+CA46 D1F9
+CA47 D1FA
+CA48 D1FB
+CA49 D1FC
+CA4A D1FD
+CA4B D1FE
+CA4C D1FF
+CA4D D200
+CA4E D201
+CA4F D202
+CA50 D203
+CA51 D204
+CA53 D205
+CA54 D206
+CA55 D207
+CA56 D208
+CA57 D209
+CA58 D20A
+CA59 D20B
+CA5A D20C
+CA5B D20D
+CA5C D20E
+CA5D D20F
+CA61 D210
+CA62 D211
+CA63 D212
+CA64 D213
+CA65 D214
+CA66 D215
+CA67 D216
+CA68 D217
+CA69 D218
+CA6A D219
+CA6B D21A
+CA6C D21B
+CA6D D21C
+CA6E D21D
+CA6F D21E
+CA70 D21F
+CA71 D220
+CA73 D221
+CA74 D222
+CA75 D223
+CA76 D224
+CA77 D225
+CA78 D226
+CA79 D227
+CA7A D228
+CA7B D229
+CA7C D22A
+CA7D D22B
+CA81 D22C
+CA82 D22D
+CA83 D22E
+CA84 D22F
+CA85 D230
+CA86 D231
+CA87 D232
+CA88 D233
+CA89 D234
+CA8A D235
+CA8B D236
+CA8C D237
+CA8D D238
+CA8E D239
+CA8F D23A
+CA90 D23B
+CA91 D23C
+CA93 D23D
+CA94 D23E
+CA95 D23F
+CA96 D240
+CA97 D241
+CA98 D242
+CA99 D243
+CA9A D244
+CA9B D245
+CA9C D246
+CA9D D247
+CAA1 D248
+CAA2 D249
+CAA3 D24A
+CAA4 D24B
+CAA5 D24C
+CAA6 D24D
+CAA7 D24E
+CAA8 D24F
+CAA9 D250
+CAAA D251
+CAAB D252
+CAAC D253
+CAAD D254
+CAAE D255
+CAAF D256
+CAB0 D257
+CAB1 D258
+CAB3 D259
+CAB4 D25A
+CAB5 D25B
+CAB6 D25C
+CAB7 D25D
+CAB8 D25E
+CAB9 D25F
+CABA D260
+CABB D261
+CABC D262
+CABD D263
+CAC1 D264
+CAC2 D265
+CAC3 D266
+CAC4 D267
+CAC5 D268
+CAC6 D269
+CAC7 D26A
+CAC8 D26B
+CAC9 D26C
+CACA D26D
+CACB D26E
+CACC D26F
+CACD D270
+CACE D271
+CACF D272
+CAD0 D273
+CAD1 D274
+CAD3 D275
+CAD4 D276
+CAD5 D277
+CAD6 D278
+CAD7 D279
+CAD8 D27A
+CAD9 D27B
+CADA D27C
+CADB D27D
+CADC D27E
+CADD D27F
+CAE1 D280
+CAE2 D281
+CAE3 D282
+CAE4 D283
+CAE5 D284
+CAE6 D285
+CAE7 D286
+CAE8 D287
+CAE9 D288
+CAEA D289
+CAEB D28A
+CAEC D28B
+CAED D28C
+CAEE D28D
+CAEF D28E
+CAF0 D28F
+CAF1 D290
+CAF3 D291
+CAF4 D292
+CAF5 D293
+CAF6 D294
+CAF7 D295
+CAF8 D296
+CAF9 D297
+CAFA D298
+CAFB D299
+CAFC D29A
+CAFD D29B
+CB41 D29C
+CB42 D29D
+CB43 D29E
+CB44 D29F
+CB45 D2A0
+CB46 D2A1
+CB47 D2A2
+CB48 D2A3
+CB49 D2A4
+CB4A D2A5
+CB4B D2A6
+CB4C D2A7
+CB4D D2A8
+CB4E D2A9
+CB4F D2AA
+CB50 D2AB
+CB51 D2AC
+CB53 D2AD
+CB54 D2AE
+CB55 D2AF
+CB56 D2B0
+CB57 D2B1
+CB58 D2B2
+CB59 D2B3
+CB5A D2B4
+CB5B D2B5
+CB5C D2B6
+CB5D D2B7
+CB61 D2B8
+CB62 D2B9
+CB63 D2BA
+CB64 D2BB
+CB65 D2BC
+CB66 D2BD
+CB67 D2BE
+CB68 D2BF
+CB69 D2C0
+CB6A D2C1
+CB6B D2C2
+CB6C D2C3
+CB6D D2C4
+CB6E D2C5
+CB6F D2C6
+CB70 D2C7
+CB71 D2C8
+CB73 D2C9
+CB74 D2CA
+CB75 D2CB
+CB76 D2CC
+CB77 D2CD
+CB78 D2CE
+CB79 D2CF
+CB7A D2D0
+CB7B D2D1
+CB7C D2D2
+CB7D D2D3
+CB81 D2D4
+CB82 D2D5
+CB83 D2D6
+CB84 D2D7
+CB85 D2D8
+CB86 D2D9
+CB87 D2DA
+CB88 D2DB
+CB89 D2DC
+CB8A D2DD
+CB8B D2DE
+CB8C D2DF
+CB8D D2E0
+CB8E D2E1
+CB8F D2E2
+CB90 D2E3
+CB91 D2E4
+CB93 D2E5
+CB94 D2E6
+CB95 D2E7
+CB96 D2E8
+CB97 D2E9
+CB98 D2EA
+CB99 D2EB
+CB9A D2EC
+CB9B D2ED
+CB9C D2EE
+CB9D D2EF
+CBA1 D2F0
+CBA2 D2F1
+CBA3 D2F2
+CBA4 D2F3
+CBA5 D2F4
+CBA6 D2F5
+CBA7 D2F6
+CBA8 D2F7
+CBA9 D2F8
+CBAA D2F9
+CBAB D2FA
+CBAC D2FB
+CBAD D2FC
+CBAE D2FD
+CBAF D2FE
+CBB0 D2FF
+CBB1 D300
+CBB3 D301
+CBB4 D302
+CBB5 D303
+CBB6 D304
+CBB7 D305
+CBB8 D306
+CBB9 D307
+CBBA D308
+CBBB D309
+CBBC D30A
+CBBD D30B
+CC41 314D
+CC61 D30C
+CC62 D30D
+CC63 D30E
+CC64 D30F
+CC65 D310
+CC66 D311
+CC67 D312
+CC68 D313
+CC69 D314
+CC6A D315
+CC6B D316
+CC6C D317
+CC6D D318
+CC6E D319
+CC6F D31A
+CC70 D31B
+CC71 D31C
+CC73 D31D
+CC74 D31E
+CC75 D31F
+CC76 D320
+CC77 D321
+CC78 D322
+CC79 D323
+CC7A D324
+CC7B D325
+CC7C D326
+CC7D D327
+CC81 D328
+CC82 D329
+CC83 D32A
+CC84 D32B
+CC85 D32C
+CC86 D32D
+CC87 D32E
+CC88 D32F
+CC89 D330
+CC8A D331
+CC8B D332
+CC8C D333
+CC8D D334
+CC8E D335
+CC8F D336
+CC90 D337
+CC91 D338
+CC93 D339
+CC94 D33A
+CC95 D33B
+CC96 D33C
+CC97 D33D
+CC98 D33E
+CC99 D33F
+CC9A D340
+CC9B D341
+CC9C D342
+CC9D D343
+CCA1 D344
+CCA2 D345
+CCA3 D346
+CCA4 D347
+CCA5 D348
+CCA6 D349
+CCA7 D34A
+CCA8 D34B
+CCA9 D34C
+CCAA D34D
+CCAB D34E
+CCAC D34F
+CCAD D350
+CCAE D351
+CCAF D352
+CCB0 D353
+CCB1 D354
+CCB3 D355
+CCB4 D356
+CCB5 D357
+CCB6 D358
+CCB7 D359
+CCB8 D35A
+CCB9 D35B
+CCBA D35C
+CCBB D35D
+CCBC D35E
+CCBD D35F
+CCC1 D360
+CCC2 D361
+CCC3 D362
+CCC4 D363
+CCC5 D364
+CCC6 D365
+CCC7 D366
+CCC8 D367
+CCC9 D368
+CCCA D369
+CCCB D36A
+CCCC D36B
+CCCD D36C
+CCCE D36D
+CCCF D36E
+CCD0 D36F
+CCD1 D370
+CCD3 D371
+CCD4 D372
+CCD5 D373
+CCD6 D374
+CCD7 D375
+CCD8 D376
+CCD9 D377
+CCDA D378
+CCDB D379
+CCDC D37A
+CCDD D37B
+CCE1 D37C
+CCE2 D37D
+CCE3 D37E
+CCE4 D37F
+CCE5 D380
+CCE6 D381
+CCE7 D382
+CCE8 D383
+CCE9 D384
+CCEA D385
+CCEB D386
+CCEC D387
+CCED D388
+CCEE D389
+CCEF D38A
+CCF0 D38B
+CCF1 D38C
+CCF3 D38D
+CCF4 D38E
+CCF5 D38F
+CCF6 D390
+CCF7 D391
+CCF8 D392
+CCF9 D393
+CCFA D394
+CCFB D395
+CCFC D396
+CCFD D397
+CD41 D398
+CD42 D399
+CD43 D39A
+CD44 D39B
+CD45 D39C
+CD46 D39D
+CD47 D39E
+CD48 D39F
+CD49 D3A0
+CD4A D3A1
+CD4B D3A2
+CD4C D3A3
+CD4D D3A4
+CD4E D3A5
+CD4F D3A6
+CD50 D3A7
+CD51 D3A8
+CD53 D3A9
+CD54 D3AA
+CD55 D3AB
+CD56 D3AC
+CD57 D3AD
+CD58 D3AE
+CD59 D3AF
+CD5A D3B0
+CD5B D3B1
+CD5C D3B2
+CD5D D3B3
+CD61 D3B4
+CD62 D3B5
+CD63 D3B6
+CD64 D3B7
+CD65 D3B8
+CD66 D3B9
+CD67 D3BA
+CD68 D3BB
+CD69 D3BC
+CD6A D3BD
+CD6B D3BE
+CD6C D3BF
+CD6D D3C0
+CD6E D3C1
+CD6F D3C2
+CD70 D3C3
+CD71 D3C4
+CD73 D3C5
+CD74 D3C6
+CD75 D3C7
+CD76 D3C8
+CD77 D3C9
+CD78 D3CA
+CD79 D3CB
+CD7A D3CC
+CD7B D3CD
+CD7C D3CE
+CD7D D3CF
+CD81 D3D0
+CD82 D3D1
+CD83 D3D2
+CD84 D3D3
+CD85 D3D4
+CD86 D3D5
+CD87 D3D6
+CD88 D3D7
+CD89 D3D8
+CD8A D3D9
+CD8B D3DA
+CD8C D3DB
+CD8D D3DC
+CD8E D3DD
+CD8F D3DE
+CD90 D3DF
+CD91 D3E0
+CD93 D3E1
+CD94 D3E2
+CD95 D3E3
+CD96 D3E4
+CD97 D3E5
+CD98 D3E6
+CD99 D3E7
+CD9A D3E8
+CD9B D3E9
+CD9C D3EA
+CD9D D3EB
+CDA1 D3EC
+CDA2 D3ED
+CDA3 D3EE
+CDA4 D3EF
+CDA5 D3F0
+CDA6 D3F1
+CDA7 D3F2
+CDA8 D3F3
+CDA9 D3F4
+CDAA D3F5
+CDAB D3F6
+CDAC D3F7
+CDAD D3F8
+CDAE D3F9
+CDAF D3FA
+CDB0 D3FB
+CDB1 D3FC
+CDB3 D3FD
+CDB4 D3FE
+CDB5 D3FF
+CDB6 D400
+CDB7 D401
+CDB8 D402
+CDB9 D403
+CDBA D404
+CDBB D405
+CDBC D406
+CDBD D407
+CDC1 D408
+CDC2 D409
+CDC3 D40A
+CDC4 D40B
+CDC5 D40C
+CDC6 D40D
+CDC7 D40E
+CDC8 D40F
+CDC9 D410
+CDCA D411
+CDCB D412
+CDCC D413
+CDCD D414
+CDCE D415
+CDCF D416
+CDD0 D417
+CDD1 D418
+CDD3 D419
+CDD4 D41A
+CDD5 D41B
+CDD6 D41C
+CDD7 D41D
+CDD8 D41E
+CDD9 D41F
+CDDA D420
+CDDB D421
+CDDC D422
+CDDD D423
+CDE1 D424
+CDE2 D425
+CDE3 D426
+CDE4 D427
+CDE5 D428
+CDE6 D429
+CDE7 D42A
+CDE8 D42B
+CDE9 D42C
+CDEA D42D
+CDEB D42E
+CDEC D42F
+CDED D430
+CDEE D431
+CDEF D432
+CDF0 D433
+CDF1 D434
+CDF3 D435
+CDF4 D436
+CDF5 D437
+CDF6 D438
+CDF7 D439
+CDF8 D43A
+CDF9 D43B
+CDFA D43C
+CDFB D43D
+CDFC D43E
+CDFD D43F
+CE41 D440
+CE42 D441
+CE43 D442
+CE44 D443
+CE45 D444
+CE46 D445
+CE47 D446
+CE48 D447
+CE49 D448
+CE4A D449
+CE4B D44A
+CE4C D44B
+CE4D D44C
+CE4E D44D
+CE4F D44E
+CE50 D44F
+CE51 D450
+CE53 D451
+CE54 D452
+CE55 D453
+CE56 D454
+CE57 D455
+CE58 D456
+CE59 D457
+CE5A D458
+CE5B D459
+CE5C D45A
+CE5D D45B
+CE61 D45C
+CE62 D45D
+CE63 D45E
+CE64 D45F
+CE65 D460
+CE66 D461
+CE67 D462
+CE68 D463
+CE69 D464
+CE6A D465
+CE6B D466
+CE6C D467
+CE6D D468
+CE6E D469
+CE6F D46A
+CE70 D46B
+CE71 D46C
+CE73 D46D
+CE74 D46E
+CE75 D46F
+CE76 D470
+CE77 D471
+CE78 D472
+CE79 D473
+CE7A D474
+CE7B D475
+CE7C D476
+CE7D D477
+CE81 D478
+CE82 D479
+CE83 D47A
+CE84 D47B
+CE85 D47C
+CE86 D47D
+CE87 D47E
+CE88 D47F
+CE89 D480
+CE8A D481
+CE8B D482
+CE8C D483
+CE8D D484
+CE8E D485
+CE8F D486
+CE90 D487
+CE91 D488
+CE93 D489
+CE94 D48A
+CE95 D48B
+CE96 D48C
+CE97 D48D
+CE98 D48E
+CE99 D48F
+CE9A D490
+CE9B D491
+CE9C D492
+CE9D D493
+CEA1 D494
+CEA2 D495
+CEA3 D496
+CEA4 D497
+CEA5 D498
+CEA6 D499
+CEA7 D49A
+CEA8 D49B
+CEA9 D49C
+CEAA D49D
+CEAB D49E
+CEAC D49F
+CEAD D4A0
+CEAE D4A1
+CEAF D4A2
+CEB0 D4A3
+CEB1 D4A4
+CEB3 D4A5
+CEB4 D4A6
+CEB5 D4A7
+CEB6 D4A8
+CEB7 D4A9
+CEB8 D4AA
+CEB9 D4AB
+CEBA D4AC
+CEBB D4AD
+CEBC D4AE
+CEBD D4AF
+CEC1 D4B0
+CEC2 D4B1
+CEC3 D4B2
+CEC4 D4B3
+CEC5 D4B4
+CEC6 D4B5
+CEC7 D4B6
+CEC8 D4B7
+CEC9 D4B8
+CECA D4B9
+CECB D4BA
+CECC D4BB
+CECD D4BC
+CECE D4BD
+CECF D4BE
+CED0 D4BF
+CED1 D4C0
+CED3 D4C1
+CED4 D4C2
+CED5 D4C3
+CED6 D4C4
+CED7 D4C5
+CED8 D4C6
+CED9 D4C7
+CEDA D4C8
+CEDB D4C9
+CEDC D4CA
+CEDD D4CB
+CEE1 D4CC
+CEE2 D4CD
+CEE3 D4CE
+CEE4 D4CF
+CEE5 D4D0
+CEE6 D4D1
+CEE7 D4D2
+CEE8 D4D3
+CEE9 D4D4
+CEEA D4D5
+CEEB D4D6
+CEEC D4D7
+CEED D4D8
+CEEE D4D9
+CEEF D4DA
+CEF0 D4DB
+CEF1 D4DC
+CEF3 D4DD
+CEF4 D4DE
+CEF5 D4DF
+CEF6 D4E0
+CEF7 D4E1
+CEF8 D4E2
+CEF9 D4E3
+CEFA D4E4
+CEFB D4E5
+CEFC D4E6
+CEFD D4E7
+CF41 D4E8
+CF42 D4E9
+CF43 D4EA
+CF44 D4EB
+CF45 D4EC
+CF46 D4ED
+CF47 D4EE
+CF48 D4EF
+CF49 D4F0
+CF4A D4F1
+CF4B D4F2
+CF4C D4F3
+CF4D D4F4
+CF4E D4F5
+CF4F D4F6
+CF50 D4F7
+CF51 D4F8
+CF53 D4F9
+CF54 D4FA
+CF55 D4FB
+CF56 D4FC
+CF57 D4FD
+CF58 D4FE
+CF59 D4FF
+CF5A D500
+CF5B D501
+CF5C D502
+CF5D D503
+CF61 D504
+CF62 D505
+CF63 D506
+CF64 D507
+CF65 D508
+CF66 D509
+CF67 D50A
+CF68 D50B
+CF69 D50C
+CF6A D50D
+CF6B D50E
+CF6C D50F
+CF6D D510
+CF6E D511
+CF6F D512
+CF70 D513
+CF71 D514
+CF73 D515
+CF74 D516
+CF75 D517
+CF76 D518
+CF77 D519
+CF78 D51A
+CF79 D51B
+CF7A D51C
+CF7B D51D
+CF7C D51E
+CF7D D51F
+CF81 D520
+CF82 D521
+CF83 D522
+CF84 D523
+CF85 D524
+CF86 D525
+CF87 D526
+CF88 D527
+CF89 D528
+CF8A D529
+CF8B D52A
+CF8C D52B
+CF8D D52C
+CF8E D52D
+CF8F D52E
+CF90 D52F
+CF91 D530
+CF93 D531
+CF94 D532
+CF95 D533
+CF96 D534
+CF97 D535
+CF98 D536
+CF99 D537
+CF9A D538
+CF9B D539
+CF9C D53A
+CF9D D53B
+CFA1 D53C
+CFA2 D53D
+CFA3 D53E
+CFA4 D53F
+CFA5 D540
+CFA6 D541
+CFA7 D542
+CFA8 D543
+CFA9 D544
+CFAA D545
+CFAB D546
+CFAC D547
+CFAD D548
+CFAE D549
+CFAF D54A
+CFB0 D54B
+CFB1 D54C
+CFB3 D54D
+CFB4 D54E
+CFB5 D54F
+CFB6 D550
+CFB7 D551
+CFB8 D552
+CFB9 D553
+CFBA D554
+CFBB D555
+CFBC D556
+CFBD D557
+D041 314E
+D061 D558
+D062 D559
+D063 D55A
+D064 D55B
+D065 D55C
+D066 D55D
+D067 D55E
+D068 D55F
+D069 D560
+D06A D561
+D06B D562
+D06C D563
+D06D D564
+D06E D565
+D06F D566
+D070 D567
+D071 D568
+D073 D569
+D074 D56A
+D075 D56B
+D076 D56C
+D077 D56D
+D078 D56E
+D079 D56F
+D07A D570
+D07B D571
+D07C D572
+D07D D573
+D081 D574
+D082 D575
+D083 D576
+D084 D577
+D085 D578
+D086 D579
+D087 D57A
+D088 D57B
+D089 D57C
+D08A D57D
+D08B D57E
+D08C D57F
+D08D D580
+D08E D581
+D08F D582
+D090 D583
+D091 D584
+D093 D585
+D094 D586
+D095 D587
+D096 D588
+D097 D589
+D098 D58A
+D099 D58B
+D09A D58C
+D09B D58D
+D09C D58E
+D09D D58F
+D0A1 D590
+D0A2 D591
+D0A3 D592
+D0A4 D593
+D0A5 D594
+D0A6 D595
+D0A7 D596
+D0A8 D597
+D0A9 D598
+D0AA D599
+D0AB D59A
+D0AC D59B
+D0AD D59C
+D0AE D59D
+D0AF D59E
+D0B0 D59F
+D0B1 D5A0
+D0B3 D5A1
+D0B4 D5A2
+D0B5 D5A3
+D0B6 D5A4
+D0B7 D5A5
+D0B8 D5A6
+D0B9 D5A7
+D0BA D5A8
+D0BB D5A9
+D0BC D5AA
+D0BD D5AB
+D0C1 D5AC
+D0C2 D5AD
+D0C3 D5AE
+D0C4 D5AF
+D0C5 D5B0
+D0C6 D5B1
+D0C7 D5B2
+D0C8 D5B3
+D0C9 D5B4
+D0CA D5B5
+D0CB D5B6
+D0CC D5B7
+D0CD D5B8
+D0CE D5B9
+D0CF D5BA
+D0D0 D5BB
+D0D1 D5BC
+D0D3 D5BD
+D0D4 D5BE
+D0D5 D5BF
+D0D6 D5C0
+D0D7 D5C1
+D0D8 D5C2
+D0D9 D5C3
+D0DA D5C4
+D0DB D5C5
+D0DC D5C6
+D0DD D5C7
+D0E1 D5C8
+D0E2 D5C9
+D0E3 D5CA
+D0E4 D5CB
+D0E5 D5CC
+D0E6 D5CD
+D0E7 D5CE
+D0E8 D5CF
+D0E9 D5D0
+D0EA D5D1
+D0EB D5D2
+D0EC D5D3
+D0ED D5D4
+D0EE D5D5
+D0EF D5D6
+D0F0 D5D7
+D0F1 D5D8
+D0F3 D5D9
+D0F4 D5DA
+D0F5 D5DB
+D0F6 D5DC
+D0F7 D5DD
+D0F8 D5DE
+D0F9 D5DF
+D0FA D5E0
+D0FB D5E1
+D0FC D5E2
+D0FD D5E3
+D141 D5E4
+D142 D5E5
+D143 D5E6
+D144 D5E7
+D145 D5E8
+D146 D5E9
+D147 D5EA
+D148 D5EB
+D149 D5EC
+D14A D5ED
+D14B D5EE
+D14C D5EF
+D14D D5F0
+D14E D5F1
+D14F D5F2
+D150 D5F3
+D151 D5F4
+D153 D5F5
+D154 D5F6
+D155 D5F7
+D156 D5F8
+D157 D5F9
+D158 D5FA
+D159 D5FB
+D15A D5FC
+D15B D5FD
+D15C D5FE
+D15D D5FF
+D161 D600
+D162 D601
+D163 D602
+D164 D603
+D165 D604
+D166 D605
+D167 D606
+D168 D607
+D169 D608
+D16A D609
+D16B D60A
+D16C D60B
+D16D D60C
+D16E D60D
+D16F D60E
+D170 D60F
+D171 D610
+D173 D611
+D174 D612
+D175 D613
+D176 D614
+D177 D615
+D178 D616
+D179 D617
+D17A D618
+D17B D619
+D17C D61A
+D17D D61B
+D181 D61C
+D182 D61D
+D183 D61E
+D184 D61F
+D185 D620
+D186 D621
+D187 D622
+D188 D623
+D189 D624
+D18A D625
+D18B D626
+D18C D627
+D18D D628
+D18E D629
+D18F D62A
+D190 D62B
+D191 D62C
+D193 D62D
+D194 D62E
+D195 D62F
+D196 D630
+D197 D631
+D198 D632
+D199 D633
+D19A D634
+D19B D635
+D19C D636
+D19D D637
+D1A1 D638
+D1A2 D639
+D1A3 D63A
+D1A4 D63B
+D1A5 D63C
+D1A6 D63D
+D1A7 D63E
+D1A8 D63F
+D1A9 D640
+D1AA D641
+D1AB D642
+D1AC D643
+D1AD D644
+D1AE D645
+D1AF D646
+D1B0 D647
+D1B1 D648
+D1B3 D649
+D1B4 D64A
+D1B5 D64B
+D1B6 D64C
+D1B7 D64D
+D1B8 D64E
+D1B9 D64F
+D1BA D650
+D1BB D651
+D1BC D652
+D1BD D653
+D1C1 D654
+D1C2 D655
+D1C3 D656
+D1C4 D657
+D1C5 D658
+D1C6 D659
+D1C7 D65A
+D1C8 D65B
+D1C9 D65C
+D1CA D65D
+D1CB D65E
+D1CC D65F
+D1CD D660
+D1CE D661
+D1CF D662
+D1D0 D663
+D1D1 D664
+D1D3 D665
+D1D4 D666
+D1D5 D667
+D1D6 D668
+D1D7 D669
+D1D8 D66A
+D1D9 D66B
+D1DA D66C
+D1DB D66D
+D1DC D66E
+D1DD D66F
+D1E1 D670
+D1E2 D671
+D1E3 D672
+D1E4 D673
+D1E5 D674
+D1E6 D675
+D1E7 D676
+D1E8 D677
+D1E9 D678
+D1EA D679
+D1EB D67A
+D1EC D67B
+D1ED D67C
+D1EE D67D
+D1EF D67E
+D1F0 D67F
+D1F1 D680
+D1F3 D681
+D1F4 D682
+D1F5 D683
+D1F6 D684
+D1F7 D685
+D1F8 D686
+D1F9 D687
+D1FA D688
+D1FB D689
+D1FC D68A
+D1FD D68B
+D241 D68C
+D242 D68D
+D243 D68E
+D244 D68F
+D245 D690
+D246 D691
+D247 D692
+D248 D693
+D249 D694
+D24A D695
+D24B D696
+D24C D697
+D24D D698
+D24E D699
+D24F D69A
+D250 D69B
+D251 D69C
+D253 D69D
+D254 D69E
+D255 D69F
+D256 D6A0
+D257 D6A1
+D258 D6A2
+D259 D6A3
+D25A D6A4
+D25B D6A5
+D25C D6A6
+D25D D6A7
+D261 D6A8
+D262 D6A9
+D263 D6AA
+D264 D6AB
+D265 D6AC
+D266 D6AD
+D267 D6AE
+D268 D6AF
+D269 D6B0
+D26A D6B1
+D26B D6B2
+D26C D6B3
+D26D D6B4
+D26E D6B5
+D26F D6B6
+D270 D6B7
+D271 D6B8
+D273 D6B9
+D274 D6BA
+D275 D6BB
+D276 D6BC
+D277 D6BD
+D278 D6BE
+D279 D6BF
+D27A D6C0
+D27B D6C1
+D27C D6C2
+D27D D6C3
+D281 D6C4
+D282 D6C5
+D283 D6C6
+D284 D6C7
+D285 D6C8
+D286 D6C9
+D287 D6CA
+D288 D6CB
+D289 D6CC
+D28A D6CD
+D28B D6CE
+D28C D6CF
+D28D D6D0
+D28E D6D1
+D28F D6D2
+D290 D6D3
+D291 D6D4
+D293 D6D5
+D294 D6D6
+D295 D6D7
+D296 D6D8
+D297 D6D9
+D298 D6DA
+D299 D6DB
+D29A D6DC
+D29B D6DD
+D29C D6DE
+D29D D6DF
+D2A1 D6E0
+D2A2 D6E1
+D2A3 D6E2
+D2A4 D6E3
+D2A5 D6E4
+D2A6 D6E5
+D2A7 D6E6
+D2A8 D6E7
+D2A9 D6E8
+D2AA D6E9
+D2AB D6EA
+D2AC D6EB
+D2AD D6EC
+D2AE D6ED
+D2AF D6EE
+D2B0 D6EF
+D2B1 D6F0
+D2B3 D6F1
+D2B4 D6F2
+D2B5 D6F3
+D2B6 D6F4
+D2B7 D6F5
+D2B8 D6F6
+D2B9 D6F7
+D2BA D6F8
+D2BB D6F9
+D2BC D6FA
+D2BD D6FB
+D2C1 D6FC
+D2C2 D6FD
+D2C3 D6FE
+D2C4 D6FF
+D2C5 D700
+D2C6 D701
+D2C7 D702
+D2C8 D703
+D2C9 D704
+D2CA D705
+D2CB D706
+D2CC D707
+D2CD D708
+D2CE D709
+D2CF D70A
+D2D0 D70B
+D2D1 D70C
+D2D3 D70D
+D2D4 D70E
+D2D5 D70F
+D2D6 D710
+D2D7 D711
+D2D8 D712
+D2D9 D713
+D2DA D714
+D2DB D715
+D2DC D716
+D2DD D717
+D2E1 D718
+D2E2 D719
+D2E3 D71A
+D2E4 D71B
+D2E5 D71C
+D2E6 D71D
+D2E7 D71E
+D2E8 D71F
+D2E9 D720
+D2EA D721
+D2EB D722
+D2EC D723
+D2ED D724
+D2EE D725
+D2EF D726
+D2F0 D727
+D2F1 D728
+D2F3 D729
+D2F4 D72A
+D2F5 D72B
+D2F6 D72C
+D2F7 D72D
+D2F8 D72E
+D2F9 D72F
+D2FA D730
+D2FB D731
+D2FC D732
+D2FD D733
+D341 D734
+D342 D735
+D343 D736
+D344 D737
+D345 D738
+D346 D739
+D347 D73A
+D348 D73B
+D349 D73C
+D34A D73D
+D34B D73E
+D34C D73F
+D34D D740
+D34E D741
+D34F D742
+D350 D743
+D351 D744
+D353 D745
+D354 D746
+D355 D747
+D356 D748
+D357 D749
+D358 D74A
+D359 D74B
+D35A D74C
+D35B D74D
+D35C D74E
+D35D D74F
+D361 D750
+D362 D751
+D363 D752
+D364 D753
+D365 D754
+D366 D755
+D367 D756
+D368 D757
+D369 D758
+D36A D759
+D36B D75A
+D36C D75B
+D36D D75C
+D36E D75D
+D36F D75E
+D370 D75F
+D371 D760
+D373 D761
+D374 D762
+D375 D763
+D376 D764
+D377 D765
+D378 D766
+D379 D767
+D37A D768
+D37B D769
+D37C D76A
+D37D D76B
+D381 D76C
+D382 D76D
+D383 D76E
+D384 D76F
+D385 D770
+D386 D771
+D387 D772
+D388 D773
+D389 D774
+D38A D775
+D38B D776
+D38C D777
+D38D D778
+D38E D779
+D38F D77A
+D390 D77B
+D391 D77C
+D393 D77D
+D394 D77E
+D395 D77F
+D396 D780
+D397 D781
+D398 D782
+D399 D783
+D39A D784
+D39B D785
+D39C D786
+D39D D787
+D3A1 D788
+D3A2 D789
+D3A3 D78A
+D3A4 D78B
+D3A5 D78C
+D3A6 D78D
+D3A7 D78E
+D3A8 D78F
+D3A9 D790
+D3AA D791
+D3AB D792
+D3AC D793
+D3AD D794
+D3AE D795
+D3AF D796
+D3B0 D797
+D3B1 D798
+D3B3 D799
+D3B4 D79A
+D3B5 D79B
+D3B6 D79C
+D3B7 D79D
+D3B8 D79E
+D3B9 D79F
+D3BA D7A0
+D3BB D7A1
+D3BC D7A2
+D3BD D7A3
+D441 E000
+D442 E001
+D443 E002
+D444 E003
+D445 E004
+D446 E005
+D447 E006
+D448 E007
+D449 E008
+D44A E009
+D44B E00A
+D44C E00B
+D44D E00C
+D44E E00D
+D44F E00E
+D450 E00F
+D451 E010
+D452 E011
+D453 E012
+D454 E013
+D455 E014
+D456 E015
+D457 E016
+D458 E017
+D459 E018
+D45A E019
+D45B E01A
+D45C E01B
+D45D E01C
+D45E E01D
+D45F E01E
+D460 E01F
+D461 E020
+D462 E021
+D463 E022
+D464 E023
+D465 E024
+D466 E025
+D467 E026
+D468 E027
+D469 E028
+D46A E029
+D46B E02A
+D46C E02B
+D46D E02C
+D46E E02D
+D46F E02E
+D470 E02F
+D471 E030
+D472 E031
+D473 E032
+D474 E033
+D475 E034
+D476 E035
+D477 E036
+D478 E037
+D479 E038
+D47A E039
+D47B E03A
+D47C E03B
+D47D E03C
+D47E E03D
+D47F E03E
+D481 E03F
+D482 E040
+D483 E041
+D484 E042
+D485 E043
+D486 E044
+D487 E045
+D488 E046
+D489 E047
+D48A E048
+D48B E049
+D48C E04A
+D48D E04B
+D48E E04C
+D48F E04D
+D490 E04E
+D491 E04F
+D492 E050
+D493 E051
+D494 E052
+D495 E053
+D496 E054
+D497 E055
+D498 E056
+D499 E057
+D49A E058
+D49B E059
+D49C E05A
+D49D E05B
+D49E E05C
+D49F E05D
+D4A0 E05E
+D4A1 E05F
+D4A2 E060
+D4A3 E061
+D4A4 E062
+D4A5 E063
+D4A6 E064
+D4A7 E065
+D4A8 E066
+D4A9 E067
+D4AA E068
+D4AB E069
+D4AC E06A
+D4AD E06B
+D4AE E06C
+D4AF E06D
+D4B0 E06E
+D4B1 E06F
+D4B2 E070
+D4B3 E071
+D4B4 E072
+D4B5 E073
+D4B6 E074
+D4B7 E075
+D4B8 E076
+D4B9 E077
+D4BA E078
+D4BB E079
+D4BC E07A
+D4BD E07B
+D4BE E07C
+D4BF E07D
+D4C0 E07E
+D4C1 E07F
+D4C2 E080
+D4C3 E081
+D4C4 E082
+D4C5 E083
+D4C6 E084
+D4C7 E085
+D4C8 E086
+D4C9 E087
+D4CA E088
+D4CB E089
+D4CC E08A
+D4CD E08B
+D4CE E08C
+D4CF E08D
+D4D0 E08E
+D4D1 E08F
+D4D2 E090
+D4D3 E091
+D4D4 E092
+D4D5 E093
+D4D6 E094
+D4D7 E095
+D4D8 E096
+D4D9 E097
+D4DA E098
+D4DB E099
+D4DC E09A
+D4DD E09B
+D4DE E09C
+D4DF E09D
+D4E0 E09E
+D4E1 E09F
+D4E2 E0A0
+D4E3 E0A1
+D4E4 E0A2
+D4E5 E0A3
+D4E6 E0A4
+D4E7 E0A5
+D4E8 E0A6
+D4E9 E0A7
+D4EA E0A8
+D4EB E0A9
+D4EC E0AA
+D4ED E0AB
+D4EE E0AC
+D4EF E0AD
+D4F0 E0AE
+D4F1 E0AF
+D4F2 E0B0
+D4F3 E0B1
+D4F4 E0B2
+D4F5 E0B3
+D4F6 E0B4
+D4F7 E0B5
+D4F8 E0B6
+D4F9 E0B7
+D4FA E0B8
+D4FB E0B9
+D4FC E0BA
+D4FD E0BB
+D541 E0BC
+D542 E0BD
+D543 E0BE
+D544 E0BF
+D545 E0C0
+D546 E0C1
+D547 E0C2
+D548 E0C3
+D549 E0C4
+D54A E0C5
+D54B E0C6
+D54C E0C7
+D54D E0C8
+D54E E0C9
+D54F E0CA
+D550 E0CB
+D551 E0CC
+D552 E0CD
+D553 E0CE
+D554 E0CF
+D555 E0D0
+D556 E0D1
+D557 E0D2
+D558 E0D3
+D559 E0D4
+D55A E0D5
+D55B E0D6
+D55C E0D7
+D55D E0D8
+D55E E0D9
+D55F E0DA
+D560 E0DB
+D561 E0DC
+D562 E0DD
+D563 E0DE
+D564 E0DF
+D565 E0E0
+D566 E0E1
+D567 E0E2
+D568 E0E3
+D569 E0E4
+D56A E0E5
+D56B E0E6
+D56C E0E7
+D56D E0E8
+D56E E0E9
+D56F E0EA
+D570 E0EB
+D571 E0EC
+D572 E0ED
+D573 E0EE
+D574 E0EF
+D575 E0F0
+D576 E0F1
+D577 E0F2
+D578 E0F3
+D579 E0F4
+D57A E0F5
+D57B E0F6
+D57C E0F7
+D57D E0F8
+D57E E0F9
+D57F E0FA
+D581 E0FB
+D582 E0FC
+D583 E0FD
+D584 E0FE
+D585 E0FF
+D586 E100
+D587 E101
+D588 E102
+D589 E103
+D58A E104
+D58B E105
+D58C E106
+D58D E107
+D58E E108
+D58F E109
+D590 E10A
+D591 E10B
+D592 E10C
+D593 E10D
+D594 E10E
+D595 E10F
+D596 E110
+D597 E111
+D598 E112
+D599 E113
+D59A E114
+D59B E115
+D59C E116
+D59D E117
+D59E E118
+D59F E119
+D5A0 E11A
+D5A1 E11B
+D5A2 E11C
+D5A3 E11D
+D5A4 E11E
+D5A5 E11F
+D5A6 E120
+D5A7 E121
+D5A8 E122
+D5A9 E123
+D5AA E124
+D5AB E125
+D5AC E126
+D5AD E127
+D5AE E128
+D5AF E129
+D5B0 E12A
+D5B1 E12B
+D5B2 E12C
+D5B3 E12D
+D5B4 E12E
+D5B5 E12F
+D5B6 E130
+D5B7 E131
+D5B8 E132
+D5B9 E133
+D5BA E134
+D5BB E135
+D5BC E136
+D5BD E137
+D5BE E138
+D5BF E139
+D5C0 E13A
+D5C1 E13B
+D5C2 E13C
+D5C3 E13D
+D5C4 E13E
+D5C5 E13F
+D5C6 E140
+D5C7 E141
+D5C8 E142
+D5C9 E143
+D5CA E144
+D5CB E145
+D5CC E146
+D5CD E147
+D5CE E148
+D5CF E149
+D5D0 E14A
+D5D1 E14B
+D5D2 E14C
+D5D3 E14D
+D5D4 E14E
+D5D5 E14F
+D5D6 E150
+D5D7 E151
+D5D8 E152
+D5D9 E153
+D5DA E154
+D5DB E155
+D5DC E156
+D5DD E157
+D5DE E158
+D5DF E159
+D5E0 E15A
+D5E1 E15B
+D5E2 E15C
+D5E3 E15D
+D5E4 E15E
+D5E5 E15F
+D5E6 E160
+D5E7 E161
+D5E8 E162
+D5E9 E163
+D5EA E164
+D5EB E165
+D5EC E166
+D5ED E167
+D5EE E168
+D5EF E169
+D5F0 E16A
+D5F1 E16B
+D5F2 E16C
+D5F3 E16D
+D5F4 E16E
+D5F5 E16F
+D5F6 E170
+D5F7 E171
+D5F8 E172
+D5F9 E173
+D5FA E174
+D5FB E175
+D5FC E176
+D5FD E177
+D641 E178
+D642 E179
+D643 E17A
+D644 E17B
+D645 E17C
+D646 E17D
+D647 E17E
+D648 E17F
+D649 E180
+D64A E181
+D64B E182
+D64C E183
+D64D E184
+D64E E185
+D64F E186
+D650 E187
+D651 E188
+D652 E189
+D653 E18A
+D654 E18B
+D655 E18C
+D656 E18D
+D657 E18E
+D658 E18F
+D659 E190
+D65A E191
+D65B E192
+D65C E193
+D65D E194
+D65E E195
+D65F E196
+D660 E197
+D661 E198
+D662 E199
+D663 E19A
+D664 E19B
+D665 E19C
+D666 E19D
+D667 E19E
+D668 E19F
+D669 E1A0
+D66A E1A1
+D66B E1A2
+D66C E1A3
+D66D E1A4
+D66E E1A5
+D66F E1A6
+D670 E1A7
+D671 E1A8
+D672 E1A9
+D673 E1AA
+D674 E1AB
+D675 E1AC
+D676 E1AD
+D677 E1AE
+D678 E1AF
+D679 E1B0
+D67A E1B1
+D67B E1B2
+D67C E1B3
+D67D E1B4
+D67E E1B5
+D67F E1B6
+D681 E1B7
+D682 E1B8
+D683 E1B9
+D684 E1BA
+D685 E1BB
+D686 E1BC
+D687 E1BD
+D688 E1BE
+D689 E1BF
+D68A E1C0
+D68B E1C1
+D68C E1C2
+D68D E1C3
+D68E E1C4
+D68F E1C5
+D690 E1C6
+D691 E1C7
+D692 E1C8
+D693 E1C9
+D694 E1CA
+D695 E1CB
+D696 E1CC
+D697 E1CD
+D698 E1CE
+D699 E1CF
+D69A E1D0
+D69B E1D1
+D69C E1D2
+D69D E1D3
+D69E E1D4
+D69F E1D5
+D6A0 E1D6
+D6A1 E1D7
+D6A2 E1D8
+D6A3 E1D9
+D6A4 E1DA
+D6A5 E1DB
+D6A6 E1DC
+D6A7 E1DD
+D6A8 E1DE
+D6A9 E1DF
+D6AA E1E0
+D6AB E1E1
+D6AC E1E2
+D6AD E1E3
+D6AE E1E4
+D6AF E1E5
+D6B0 E1E6
+D6B1 E1E7
+D6B2 E1E8
+D6B3 E1E9
+D6B4 E1EA
+D6B5 E1EB
+D6B6 E1EC
+D6B7 E1ED
+D6B8 E1EE
+D6B9 E1EF
+D6BA E1F0
+D6BB E1F1
+D6BC E1F2
+D6BD E1F3
+D6BE E1F4
+D6BF E1F5
+D6C0 E1F6
+D6C1 E1F7
+D6C2 E1F8
+D6C3 E1F9
+D6C4 E1FA
+D6C5 E1FB
+D6C6 E1FC
+D6C7 E1FD
+D6C8 E1FE
+D6C9 E1FF
+D6CA E200
+D6CB E201
+D6CC E202
+D6CD E203
+D6CE E204
+D6CF E205
+D6D0 E206
+D6D1 E207
+D6D2 E208
+D6D3 E209
+D6D4 E20A
+D6D5 E20B
+D6D6 E20C
+D6D7 E20D
+D6D8 E20E
+D6D9 E20F
+D6DA E210
+D6DB E211
+D6DC E212
+D6DD E213
+D6DE E214
+D6DF E215
+D6E0 E216
+D6E1 E217
+D6E2 E218
+D6E3 E219
+D6E4 E21A
+D6E5 E21B
+D6E6 E21C
+D6E7 E21D
+D6E8 E21E
+D6E9 E21F
+D6EA E220
+D6EB E221
+D6EC E222
+D6ED E223
+D6EE E224
+D6EF E225
+D6F0 E226
+D6F1 E227
+D6F2 E228
+D6F3 E229
+D6F4 E22A
+D6F5 E22B
+D6F6 E22C
+D6F7 E22D
+D6F8 E22E
+D6F9 E22F
+D6FA E230
+D6FB E231
+D6FC E232
+D6FD E233
+D741 E234
+D742 E235
+D743 E236
+D744 E237
+D745 E238
+D746 E239
+D747 E23A
+D748 E23B
+D749 E23C
+D74A E23D
+D74B E23E
+D74C E23F
+D74D E240
+D74E E241
+D74F E242
+D750 E243
+D751 E244
+D752 E245
+D753 E246
+D754 E247
+D755 E248
+D756 E249
+D757 E24A
+D758 E24B
+D759 E24C
+D75A E24D
+D75B E24E
+D75C E24F
+D75D E250
+D75E E251
+D75F E252
+D760 E253
+D761 E254
+D762 E255
+D763 E256
+D764 E257
+D765 E258
+D766 E259
+D767 E25A
+D768 E25B
+D769 E25C
+D76A E25D
+D76B E25E
+D76C E25F
+D76D E260
+D76E E261
+D76F E262
+D770 E263
+D771 E264
+D772 E265
+D773 E266
+D774 E267
+D775 E268
+D776 E269
+D777 E26A
+D778 E26B
+D779 E26C
+D77A E26D
+D77B E26E
+D77C E26F
+D77D E270
+D77E E271
+D77F E272
+D781 E273
+D782 E274
+D783 E275
+D784 E276
+D785 E277
+D786 E278
+D787 E279
+D788 E27A
+D789 E27B
+D78A E27C
+D78B E27D
+D78C E27E
+D78D E27F
+D78E E280
+D78F E281
+D790 E282
+D791 E283
+D792 E284
+D793 E285
+D794 E286
+D795 E287
+D796 E288
+D797 E289
+D798 E28A
+D799 E28B
+D79A E28C
+D79B E28D
+D79C E28E
+D79D E28F
+D79E E290
+D79F E291
+D7A0 E292
+D7A1 E293
+D7A2 E294
+D7A3 E295
+D7A4 E296
+D7A5 E297
+D7A6 E298
+D7A7 E299
+D7A8 E29A
+D7A9 E29B
+D7AA E29C
+D7AB E29D
+D7AC E29E
+D7AD E29F
+D7AE E2A0
+D7AF E2A1
+D7B0 E2A2
+D7B1 E2A3
+D7B2 E2A4
+D7B3 E2A5
+D7B4 E2A6
+D7B5 E2A7
+D7B6 E2A8
+D7B7 E2A9
+D7B8 E2AA
+D7B9 E2AB
+D7BA E2AC
+D7BB E2AD
+D7BC E2AE
+D7BD E2AF
+D7BE E2B0
+D7BF E2B1
+D7C0 E2B2
+D7C1 E2B3
+D7C2 E2B4
+D7C3 E2B5
+D7C4 E2B6
+D7C5 E2B7
+D7C6 E2B8
+D7C7 E2B9
+D7C8 E2BA
+D7C9 E2BB
+D7CA E2BC
+D7CB E2BD
+D7CC E2BE
+D7CD E2BF
+D7CE E2C0
+D7CF E2C1
+D7D0 E2C2
+D7D1 E2C3
+D7D2 E2C4
+D7D3 E2C5
+D7D4 E2C6
+D7D5 E2C7
+D7D6 E2C8
+D7D7 E2C9
+D7D8 E2CA
+D7D9 E2CB
+D7DA E2CC
+D7DB E2CD
+D7DC E2CE
+D7DD E2CF
+D7DE E2D0
+D7DF E2D1
+D7E0 E2D2
+D7E1 E2D3
+D7E2 E2D4
+D7E3 E2D5
+D7E4 E2D6
+D7E5 E2D7
+D7E6 E2D8
+D7E7 E2D9
+D7E8 E2DA
+D7E9 E2DB
+D7EA E2DC
+D7EB E2DD
+D7EC E2DE
+D7ED E2DF
+D7EE E2E0
+D7EF E2E1
+D7F0 E2E2
+D7F1 E2E3
+D7F2 E2E4
+D7F3 E2E5
+D7F4 E2E6
+D7F5 E2E7
+D7F6 E2E8
+D7F7 E2E9
+D7F8 E2EA
+D7F9 E2EB
+D7FA E2EC
+D7FB E2ED
+D7FC E2EE
+D7FD E2EF
+D841 E2F0
+D842 E2F1
+D843 E2F2
+D844 E2F3
+D845 E2F4
+D846 E2F5
+D847 E2F6
+D848 E2F7
+D849 E2F8
+D84A E2F9
+D84B E2FA
+D84C E2FB
+D84D E2FC
+D84E E2FD
+D84F E2FE
+D850 E2FF
+D851 E300
+D852 E301
+D853 E302
+D854 E303
+D855 E304
+D856 E305
+D857 E306
+D858 E307
+D859 E308
+D85A E309
+D85B E30A
+D85C E30B
+D85D E30C
+D85E E30D
+D85F E30E
+D860 E30F
+D861 E310
+D862 E311
+D863 E312
+D864 E313
+D865 E314
+D866 E315
+D867 E316
+D868 E317
+D869 E318
+D86A E319
+D86B E31A
+D86C E31B
+D86D E31C
+D86E E31D
+D86F E31E
+D870 E31F
+D871 E320
+D872 E321
+D873 E322
+D874 E323
+D875 E324
+D876 E325
+D877 E326
+D878 E327
+D879 E328
+D87A E329
+D87B E32A
+D87C E32B
+D87D E32C
+D87E E32D
+D87F E32E
+D881 E32F
+D882 E330
+D883 E331
+D884 E332
+D885 E333
+D886 E334
+D887 E335
+D888 E336
+D889 E337
+D88A E338
+D88B E339
+D88C E33A
+D88D E33B
+D88E E33C
+D88F E33D
+D890 E33E
+D891 E33F
+D892 E340
+D893 E341
+D894 E342
+D895 E343
+D896 E344
+D897 E345
+D898 E346
+D899 E347
+D89A E348
+D89B E349
+D89C E34A
+D89D E34B
+D89E E34C
+D89F E34D
+D8A0 E34E
+D8A1 E34F
+D8A2 E350
+D8A3 E351
+D8A4 E352
+D8A5 E353
+D8A6 E354
+D8A7 E355
+D8A8 E356
+D8A9 E357
+D8AA E358
+D8AB E359
+D8AC E35A
+D8AD E35B
+D8AE E35C
+D8AF E35D
+D8B0 E35E
+D8B1 E35F
+D8B2 E360
+D8B3 E361
+D8B4 E362
+D8B5 E363
+D8B6 E364
+D8B7 E365
+D8B8 E366
+D8B9 E367
+D8BA E368
+D8BB E369
+D8BC E36A
+D8BD E36B
+D8BE E36C
+D8BF E36D
+D8C0 E36E
+D8C1 E36F
+D8C2 E370
+D8C3 E371
+D8C4 E372
+D8C5 E373
+D8C6 E374
+D8C7 E375
+D8C8 E376
+D8C9 E377
+D8CA E378
+D8CB E379
+D8CC E37A
+D8CD E37B
+D8CE E37C
+D8CF E37D
+D8D0 E37E
+D8D1 E37F
+D8D2 E380
+D8D3 E381
+D8D4 E382
+D8D5 E383
+D8D6 E384
+D8D7 E385
+D8D8 E386
+D8D9 E387
+D8DA E388
+D8DB E389
+D8DC E38A
+D8DD E38B
+D8DE E38C
+D8DF E38D
+D8E0 E38E
+D8E1 E38F
+D8E2 E390
+D8E3 E391
+D8E4 E392
+D8E5 E393
+D8E6 E394
+D8E7 E395
+D8E8 E396
+D8E9 E397
+D8EA E398
+D8EB E399
+D8EC E39A
+D8ED E39B
+D8EE E39C
+D8EF E39D
+D8F0 E39E
+D8F1 E39F
+D8F2 E3A0
+D8F3 E3A1
+D8F4 E3A2
+D8F5 E3A3
+D8F6 E3A4
+D8F7 E3A5
+D8F8 E3A6
+D8F9 E3A7
+D8FA E3A8
+D8FB E3A9
+D8FC E3AA
+D8FD E3AB
+D941 E3AC
+D942 E3AD
+D943 E3AE
+D944 E3AF
+D945 E3B0
+D946 E3B1
+D947 E3B2
+D948 E3B3
+D949 E3B4
+D94A E3B5
+D94B E3B6
+D94C E3B7
+D94D E3B8
+D94E E3B9
+D94F E3BA
+D950 E3BB
+D951 E3BC
+D952 E3BD
+D953 E3BE
+D954 E3BF
+D955 E3C0
+D956 E3C1
+D957 E3C2
+D958 E3C3
+D959 E3C4
+D95A E3C5
+D95B E3C6
+D95C E3C7
+D95D E3C8
+D95E E3C9
+D95F E3CA
+D960 E3CB
+D961 E3CC
+D962 E3CD
+D963 E3CE
+D964 E3CF
+D965 E3D0
+D966 E3D1
+D967 E3D2
+D968 E3D3
+D969 E3D4
+D96A E3D5
+D96B E3D6
+D96C E3D7
+D96D E3D8
+D96E E3D9
+D96F E3DA
+D970 E3DB
+D971 E3DC
+D972 E3DD
+D973 E3DE
+D974 E3DF
+D975 E3E0
+D976 E3E1
+D977 E3E2
+D978 E3E3
+D979 E3E4
+D97A E3E5
+D97B E3E6
+D97C E3E7
+D97D E3E8
+D97E E3E9
+D97F E3EA
+D981 E3EB
+D982 E3EC
+D983 E3ED
+D984 E3EE
+D985 E3EF
+D986 E3F0
+D987 E3F1
+D988 E3F2
+D989 E3F3
+D98A E3F4
+D98B E3F5
+D98C E3F6
+D98D E3F7
+D98E E3F8
+D98F E3F9
+D990 E3FA
+D991 E3FB
+D992 E3FC
+D993 E3FD
+D994 E3FE
+D995 E3FF
+D996 E400
+D997 E401
+D998 E402
+D999 E403
+D99A E404
+D99B E405
+D99C E406
+D99D E407
+D99E E408
+D99F E409
+D9A0 E40A
+D9A1 E40B
+D9A2 E40C
+D9A3 E40D
+D9A4 E40E
+D9A5 E40F
+D9A6 E410
+D9A7 E411
+D9A8 E412
+D9A9 E413
+D9AA E414
+D9AB E415
+D9AC E416
+D9AD E417
+D9AE E418
+D9AF E419
+D9B0 E41A
+D9B1 E41B
+D9B2 E41C
+D9B3 E41D
+D9B4 E41E
+D9B5 E41F
+D9B6 E420
+D9B7 E421
+D9B8 E422
+D9B9 E423
+D9BA E424
+D9BB E425
+D9BC E426
+D9BD E427
+D9BE E428
+D9BF E429
+D9C0 E42A
+D9C1 E42B
+D9C2 E42C
+D9C3 E42D
+D9C4 E42E
+D9C5 E42F
+D9C6 E430
+D9C7 E431
+D9C8 E432
+D9C9 E433
+D9CA E434
+D9CB E435
+D9CC E436
+D9CD E437
+D9CE E438
+D9CF E439
+D9D0 E43A
+D9D1 E43B
+D9D2 E43C
+D9D3 E43D
+D9D4 E43E
+D9D5 E43F
+D9D6 E440
+D9D7 E441
+D9D8 E442
+D9D9 E443
+D9DA E444
+D9DB E445
+D9DC E446
+D9DD E447
+D9DE E448
+D9DF E449
+D9E0 E44A
+D9E1 E44B
+D9E2 E44C
+D9E3 E44D
+D9E4 E44E
+D9E5 E44F
+D9E6 E450
+D9E7 E451
+D9E8 E452
+D9E9 E453
+D9EA E454
+D9EB E455
+D9EC E456
+D9ED E457
+D9EE E458
+D9EF E459
+D9F0 E45A
+D9F1 E45B
+D9F2 E45C
+D9F3 E45D
+D9F4 E45E
+D9F5 E45F
+D9F6 E460
+D9F7 E461
+D9F8 E462
+D9F9 E463
+D9FA E464
+D9FB E465
+D9FC E466
+D9FD E467
+DA41 E468
+DA42 E469
+DA43 E46A
+DA44 E46B
+DA45 E46C
+DA46 E46D
+DA47 E46E
+DA48 E46F
+DA49 E470
+DA4A E471
+DA4B E472
+DA4C E473
+DA4D E474
+DA4E E475
+DA4F E476
+DA50 E477
+DA51 E478
+DA52 E479
+DA53 E47A
+DA54 E47B
+DA55 E47C
+DA56 E47D
+DA57 E47E
+DA58 E47F
+DA59 E480
+DA5A E481
+DA5B E482
+DA5C E483
+DA5D E484
+DA5E E485
+DA5F E486
+DA60 E487
+DA61 E488
+DA62 E489
+DA63 E48A
+DA64 E48B
+DA65 E48C
+DA66 E48D
+DA67 E48E
+DA68 E48F
+DA69 E490
+DA6A E491
+DA6B E492
+DA6C E493
+DA6D E494
+DA6E E495
+DA6F E496
+DA70 E497
+DA71 E498
+DA72 E499
+DA73 E49A
+DA74 E49B
+DA75 E49C
+DA76 E49D
+DA77 E49E
+DA78 E49F
+DA79 E4A0
+DA7A E4A1
+DA7B E4A2
+DA7C E4A3
+DA7D E4A4
+DA7E E4A5
+DA7F E4A6
+DA81 E4A7
+DA82 E4A8
+DA83 E4A9
+DA84 E4AA
+DA85 E4AB
+DA86 E4AC
+DA87 E4AD
+DA88 E4AE
+DA89 E4AF
+DA8A E4B0
+DA8B E4B1
+DA8C E4B2
+DA8D E4B3
+DA8E E4B4
+DA8F E4B5
+DA90 E4B6
+DA91 E4B7
+DA92 E4B8
+DA93 E4B9
+DA94 E4BA
+DA95 E4BB
+DA96 E4BC
+DA97 E4BD
+DA98 E4BE
+DA99 E4BF
+DA9A E4C0
+DA9B E4C1
+DA9C E4C2
+DA9D E4C3
+DA9E E4C4
+DA9F E4C5
+DAA0 E4C6
+DAA1 E4C7
+DAA2 E4C8
+DAA3 E4C9
+DAA4 E4CA
+DAA5 E4CB
+DAA6 E4CC
+DAA7 E4CD
+DAA8 E4CE
+DAA9 E4CF
+DAAA E4D0
+DAAB E4D1
+DAAC E4D2
+DAAD E4D3
+DAAE E4D4
+DAAF E4D5
+DAB0 E4D6
+DAB1 E4D7
+DAB2 E4D8
+DAB3 E4D9
+DAB4 E4DA
+DAB5 E4DB
+DAB6 E4DC
+DAB7 E4DD
+DAB8 E4DE
+DAB9 E4DF
+DABA E4E0
+DABB E4E1
+DABC E4E2
+DABD E4E3
+DABE E4E4
+DABF E4E5
+DAC0 E4E6
+DAC1 E4E7
+DAC2 E4E8
+DAC3 E4E9
+DAC4 E4EA
+DAC5 E4EB
+DAC6 E4EC
+DAC7 E4ED
+DAC8 E4EE
+DAC9 E4EF
+DACA E4F0
+DACB E4F1
+DACC E4F2
+DACD E4F3
+DACE E4F4
+DACF E4F5
+DAD0 E4F6
+DAD1 E4F7
+DAD2 E4F8
+DAD3 E4F9
+DAD4 E4FA
+DAD5 E4FB
+DAD6 E4FC
+DAD7 E4FD
+DAD8 E4FE
+DAD9 E4FF
+DADA E500
+DADB E501
+DADC E502
+DADD E503
+DADE E504
+DADF E505
+DAE0 E506
+DAE1 E507
+DAE2 E508
+DAE3 E509
+DAE4 E50A
+DAE5 E50B
+DAE6 E50C
+DAE7 E50D
+DAE8 E50E
+DAE9 E50F
+DAEA E510
+DAEB E511
+DAEC E512
+DAED E513
+DAEE E514
+DAEF E515
+DAF0 E516
+DAF1 E517
+DAF2 E518
+DAF3 E519
+DAF4 E51A
+DAF5 E51B
+DAF6 E51C
+DAF7 E51D
+DAF8 E51E
+DAF9 E51F
+DAFA E520
+DAFB E521
+DAFC E522
+DAFD E523
+DB41 E524
+DB42 E525
+DB43 E526
+DB44 E527
+DB45 E528
+DB46 E529
+DB47 E52A
+DB48 E52B
+DB49 E52C
+DB4A E52D
+DB4B E52E
+DB4C E52F
+DB4D E530
+DB4E E531
+DB4F E532
+DB50 E533
+DB51 E534
+DB52 E535
+DB53 E536
+DB54 E537
+DB55 E538
+DB56 E539
+DB57 E53A
+DB58 E53B
+DB59 E53C
+DB5A E53D
+DB5B E53E
+DB5C E53F
+DB5D E540
+DB5E E541
+DB5F E542
+DB60 E543
+DB61 E544
+DB62 E545
+DB63 E546
+DB64 E547
+DB65 E548
+DB66 E549
+DB67 E54A
+DB68 E54B
+DB69 E54C
+DB6A E54D
+DB6B E54E
+DB6C E54F
+DB6D E550
+DB6E E551
+DB6F E552
+DB70 E553
+DB71 E554
+DB72 E555
+DB73 E556
+DB74 E557
+DB75 E558
+DB76 E559
+DB77 E55A
+DB78 E55B
+DB79 E55C
+DB7A E55D
+DB7B E55E
+DB7C E55F
+DB7D E560
+DB7E E561
+DB7F E562
+DB81 E563
+DB82 E564
+DB83 E565
+DB84 E566
+DB85 E567
+DB86 E568
+DB87 E569
+DB88 E56A
+DB89 E56B
+DB8A E56C
+DB8B E56D
+DB8C E56E
+DB8D E56F
+DB8E E570
+DB8F E571
+DB90 E572
+DB91 E573
+DB92 E574
+DB93 E575
+DB94 E576
+DB95 E577
+DB96 E578
+DB97 E579
+DB98 E57A
+DB99 E57B
+DB9A E57C
+DB9B E57D
+DB9C E57E
+DB9D E57F
+DB9E E580
+DB9F E581
+DBA0 E582
+DBA1 E583
+DBA2 E584
+DBA3 E585
+DBA4 E586
+DBA5 E587
+DBA6 E588
+DBA7 E589
+DBA8 E58A
+DBA9 E58B
+DBAA E58C
+DBAB E58D
+DBAC E58E
+DBAD E58F
+DBAE E590
+DBAF E591
+DBB0 E592
+DBB1 E593
+DBB2 E594
+DBB3 E595
+DBB4 E596
+DBB5 E597
+DBB6 E598
+DBB7 E599
+DBB8 E59A
+DBB9 E59B
+DBBA E59C
+DBBB E59D
+DBBC E59E
+DBBD E59F
+DBBE E5A0
+DBBF E5A1
+DBC0 E5A2
+DBC1 E5A3
+DBC2 E5A4
+DBC3 E5A5
+DBC4 E5A6
+DBC5 E5A7
+DBC6 E5A8
+DBC7 E5A9
+DBC8 E5AA
+DBC9 E5AB
+DBCA E5AC
+DBCB E5AD
+DBCC E5AE
+DBCD E5AF
+DBCE E5B0
+DBCF E5B1
+DBD0 E5B2
+DBD1 E5B3
+DBD2 E5B4
+DBD3 E5B5
+DBD4 E5B6
+DBD5 E5B7
+DBD6 E5B8
+DBD7 E5B9
+DBD8 E5BA
+DBD9 E5BB
+DBDA E5BC
+DBDB E5BD
+DBDC E5BE
+DBDD E5BF
+DBDE E5C0
+DBDF E5C1
+DBE0 E5C2
+DBE1 E5C3
+DBE2 E5C4
+DBE3 E5C5
+DBE4 E5C6
+DBE5 E5C7
+DBE6 E5C8
+DBE7 E5C9
+DBE8 E5CA
+DBE9 E5CB
+DBEA E5CC
+DBEB E5CD
+DBEC E5CE
+DBED E5CF
+DBEE E5D0
+DBEF E5D1
+DBF0 E5D2
+DBF1 E5D3
+DBF2 E5D4
+DBF3 E5D5
+DBF4 E5D6
+DBF5 E5D7
+DBF6 E5D8
+DBF7 E5D9
+DBF8 E5DA
+DBF9 E5DB
+DBFA E5DC
+DBFB E5DD
+DBFC E5DE
+DBFD E5DF
+DC41 E5E0
+DC42 E5E1
+DC43 E5E2
+DC44 E5E3
+DC45 E5E4
+DC46 E5E5
+DC47 E5E6
+DC48 E5E7
+DC49 E5E8
+DC4A E5E9
+DC4B E5EA
+DC4C E5EB
+DC4D E5EC
+DC4E E5ED
+DC4F E5EE
+DC50 E5EF
+DC51 E5F0
+DC52 E5F1
+DC53 E5F2
+DC54 E5F3
+DC55 E5F4
+DC56 E5F5
+DC57 E5F6
+DC58 E5F7
+DC59 E5F8
+DC5A E5F9
+DC5B E5FA
+DC5C E5FB
+DC5D E5FC
+DC5E E5FD
+DC5F E5FE
+DC60 E5FF
+DC61 E600
+DC62 E601
+DC63 E602
+DC64 E603
+DC65 E604
+DC66 E605
+DC67 E606
+DC68 E607
+DC69 E608
+DC6A E609
+DC6B E60A
+DC6C E60B
+DC6D E60C
+DC6E E60D
+DC6F E60E
+DC70 E60F
+DC71 E610
+DC72 E611
+DC73 E612
+DC74 E613
+DC75 E614
+DC76 E615
+DC77 E616
+DC78 E617
+DC79 E618
+DC7A E619
+DC7B E61A
+DC7C E61B
+DC7D E61C
+DC7E E61D
+DC7F E61E
+DC81 E61F
+DC82 E620
+DC83 E621
+DC84 E622
+DC85 E623
+DC86 E624
+DC87 E625
+DC88 E626
+DC89 E627
+DC8A E628
+DC8B E629
+DC8C E62A
+DC8D E62B
+DC8E E62C
+DC8F E62D
+DC90 E62E
+DC91 E62F
+DC92 E630
+DC93 E631
+DC94 E632
+DC95 E633
+DC96 E634
+DC97 E635
+DC98 E636
+DC99 E637
+DC9A E638
+DC9B E639
+DC9C E63A
+DC9D E63B
+DC9E E63C
+DC9F E63D
+DCA0 E63E
+DCA1 E63F
+DCA2 E640
+DCA3 E641
+DCA4 E642
+DCA5 E643
+DCA6 E644
+DCA7 E645
+DCA8 E646
+DCA9 E647
+DCAA E648
+DCAB E649
+DCAC E64A
+DCAD E64B
+DCAE E64C
+DCAF E64D
+DCB0 E64E
+DCB1 E64F
+DCB2 E650
+DCB3 E651
+DCB4 E652
+DCB5 E653
+DCB6 E654
+DCB7 E655
+DCB8 E656
+DCB9 E657
+DCBA E658
+DCBB E659
+DCBC E65A
+DCBD E65B
+DCBE E65C
+DCBF E65D
+DCC0 E65E
+DCC1 E65F
+DCC2 E660
+DCC3 E661
+DCC4 E662
+DCC5 E663
+DCC6 E664
+DCC7 E665
+DCC8 E666
+DCC9 E667
+DCCA E668
+DCCB E669
+DCCC E66A
+DCCD E66B
+DCCE E66C
+DCCF E66D
+DCD0 E66E
+DCD1 E66F
+DCD2 E670
+DCD3 E671
+DCD4 E672
+DCD5 E673
+DCD6 E674
+DCD7 E675
+DCD8 E676
+DCD9 E677
+DCDA E678
+DCDB E679
+DCDC E67A
+DCDD E67B
+DCDE E67C
+DCDF E67D
+DCE0 E67E
+DCE1 E67F
+DCE2 E680
+DCE3 E681
+DCE4 E682
+DCE5 E683
+DCE6 E684
+DCE7 E685
+DCE8 E686
+DCE9 E687
+DCEA E688
+DCEB E689
+DCEC E68A
+DCED E68B
+DCEE E68C
+DCEF E68D
+DCF0 E68E
+DCF1 E68F
+DCF2 E690
+DCF3 E691
+DCF4 E692
+DCF5 E693
+DCF6 E694
+DCF7 E695
+DCF8 E696
+DCF9 E697
+DCFA E698
+DCFB E699
+DCFC E69A
+DCFD E69B
+DD41 E69C
+DD42 E69D
+DD43 E69E
+DD44 E69F
+DD45 E6A0
+DD46 E6A1
+DD47 E6A2
+DD48 E6A3
+DD49 E6A4
+DD4A E6A5
+DD4B E6A6
+DD4C E6A7
+DD4D E6A8
+DD4E E6A9
+DD4F E6AA
+DD50 E6AB
+DD51 E6AC
+DD52 E6AD
+DD53 E6AE
+DD54 E6AF
+DD55 E6B0
+DD56 E6B1
+DD57 E6B2
+DD58 E6B3
+DD59 E6B4
+DD5A E6B5
+DD5B E6B6
+DD5C E6B7
+DD5D E6B8
+DD5E E6B9
+DD5F E6BA
+DD60 E6BB
+DD61 E6BC
+DD62 E6BD
+DD63 E6BE
+DD64 E6BF
+DD65 E6C0
+DD66 E6C1
+DD67 E6C2
+DD68 E6C3
+DD69 E6C4
+DD6A E6C5
+DD6B E6C6
+DD6C E6C7
+DD6D E6C8
+DD6E E6C9
+DD6F E6CA
+DD70 E6CB
+DD71 E6CC
+DD72 E6CD
+DD73 E6CE
+DD74 E6CF
+DD75 E6D0
+DD76 E6D1
+DD77 E6D2
+DD78 E6D3
+DD79 E6D4
+DD7A E6D5
+DD7B E6D6
+DD7C E6D7
+DD7D E6D8
+DD7E E6D9
+DD7F E6DA
+DD81 E6DB
+DD82 E6DC
+DD83 E6DD
+DD84 E6DE
+DD85 E6DF
+DD86 E6E0
+DD87 E6E1
+DD88 E6E2
+DD89 E6E3
+DD8A E6E4
+DD8B E6E5
+DD8C E6E6
+DD8D E6E7
+DD8E E6E8
+DD8F E6E9
+DD90 E6EA
+DD91 E6EB
+DD92 E6EC
+DD93 E6ED
+DD94 E6EE
+DD95 E6EF
+DD96 E6F0
+DD97 E6F1
+DD98 E6F2
+DD99 E6F3
+DD9A E6F4
+DD9B E6F5
+DD9C E6F6
+DD9D E6F7
+DD9E E6F8
+DD9F E6F9
+DDA0 E6FA
+DDA1 E6FB
+DDA2 E6FC
+DDA3 E6FD
+DDA4 E6FE
+DDA5 E6FF
+DDA6 E700
+DDA7 E701
+DDA8 E702
+DDA9 E703
+DDAA E704
+DDAB E705
+DDAC E706
+DDAD E707
+DDAE E708
+DDAF E709
+DDB0 E70A
+DDB1 E70B
+DDB2 E70C
+DDB3 E70D
+DDB4 E70E
+DDB5 E70F
+DDB6 E710
+DDB7 E711
+DDB8 E712
+DDB9 E713
+DDBA E714
+DDBB E715
+DDBC E716
+DDBD E717
+DDBE E718
+DDBF E719
+DDC0 E71A
+DDC1 E71B
+DDC2 E71C
+DDC3 E71D
+DDC4 E71E
+DDC5 E71F
+DDC6 E720
+DDC7 E721
+DDC8 E722
+DDC9 E723
+DDCA E724
+DDCB E725
+DDCC E726
+DDCD E727
+DDCE E728
+DDCF E729
+DDD0 E72A
+DDD1 E72B
+DDD2 E72C
+DDD3 E72D
+DDD4 E72E
+DDD5 E72F
+DDD6 E730
+DDD7 E731
+DDD8 E732
+DDD9 E733
+DDDA E734
+DDDB E735
+DDDC E736
+DDDD E737
+DDDE E738
+DDDF E739
+DDE0 E73A
+DDE1 E73B
+DDE2 E73C
+DDE3 E73D
+DDE4 E73E
+DDE5 E73F
+DDE6 E740
+DDE7 E741
+DDE8 E742
+DDE9 E743
+DDEA E744
+DDEB E745
+DDEC E746
+DDED E747
+DDEE E748
+DDEF E749
+DDF0 E74A
+DDF1 E74B
+DDF2 E74C
+DDF3 E74D
+DDF4 E74E
+DDF5 E74F
+DDF6 E750
+DDF7 E751
+DDF8 E752
+DDF9 E753
+DDFA E754
+DDFB E755
+DDFC E756
+DDFD E757
--- a/jdk/make/tools/CharsetMapping/dbcs Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/tools/CharsetMapping/dbcs Mon Mar 21 16:57:18 2011 -0700
@@ -10,6 +10,7 @@
MS949 x-windows-949 MS949 basic sun.nio.cs.ext true 0x81 0xfe 0x41 0xfe
MS950 x-windows-950 MS950 basic sun.nio.cs.ext true 0x81 0xfe 0x40 0xfe
GBK GBK GBK basic sun.nio.cs.ext true 0x81 0xfe 0x40 0xfe
+IBM1364 x-IBM1364 Cp1364 ebcdic sun.nio.cs.ext false 0x40 0xde 0x40 0xfe
IBM1381 x-IBM1381 Cp1381 basic sun.nio.cs.ext true 0x8c 0xf7 0xa1 0xfe
IBM1383 x-IBM1383 Cp1383 euc_sim sun.nio.cs.ext true 0xa1 0xfe 0xa1 0xfe
IBM930 x-IBM930 Cp930 ebcdic sun.nio.cs.ext false 0x40 0x7f 0x40 0xfe
--- a/jdk/make/tools/Makefile Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/make/tools/Makefile Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@@ -30,6 +30,7 @@
BUILDDIR = ..
include $(BUILDDIR)/common/Defs.gmk
+# Note: freetypecheck is built by Sanity.gmk if needed
SUBDIRS = \
addjsum \
buildmetaindex \
@@ -38,7 +39,6 @@
compile_properties \
dir_diff \
dtdbuilder \
- freetypecheck \
generate_break_iterator \
GenerateCharacter \
generatecurrencydata \
--- a/jdk/src/share/bin/java.c Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/bin/java.c Mon Mar 21 16:57:18 2011 -0700
@@ -61,6 +61,9 @@
* interfaces.
*/
+/* we always print to stderr */
+#define USE_STDERR JNI_TRUE
+
static jboolean printVersion = JNI_FALSE; /* print and exit */
static jboolean showVersion = JNI_FALSE; /* print but continue */
static jboolean printUsage = JNI_FALSE; /* print and exit*/
@@ -1136,36 +1139,18 @@
return; \
}
-static jstring platformEncoding = NULL;
-static jstring getPlatformEncoding(JNIEnv *env) {
- if (platformEncoding == NULL) {
- jstring propname = (*env)->NewStringUTF(env, "sun.jnu.encoding");
- if (propname) {
- jclass cls;
- jmethodID mid;
- NULL_CHECK0 (cls = FindBootStrapClass(env, "java/lang/System"));
- NULL_CHECK0 (mid = (*env)->GetStaticMethodID(
- env, cls,
- "getProperty",
- "(Ljava/lang/String;)Ljava/lang/String;"));
- platformEncoding = (*env)->CallStaticObjectMethod (
- env, cls, mid, propname);
- }
+static jclass helperClass = NULL;
+
+static jclass
+GetLauncherHelperClass(JNIEnv *env) {
+ if (helperClass == NULL) {
+ NULL_CHECK0(helperClass = FindBootStrapClass(env,
+ "sun/launcher/LauncherHelper"));
}
- return platformEncoding;
+ return helperClass;
}
-static jboolean isEncodingSupported(JNIEnv *env, jstring enc) {
- jclass cls;
- jmethodID mid;
- NULL_CHECK0 (cls = FindBootStrapClass(env, "java/nio/charset/Charset"));
- NULL_CHECK0 (mid = (*env)->GetStaticMethodID(
- env, cls,
- "isSupported",
- "(Ljava/lang/String;)Z"));
- return (*env)->CallStaticBooleanMethod(env, cls, mid, enc);
-}
-
+static jmethodID makePlatformStringMID = NULL;
/*
* Returns a new Java string object for the specified platform string.
*/
@@ -1173,36 +1158,23 @@
NewPlatformString(JNIEnv *env, char *s)
{
int len = (int)JLI_StrLen(s);
- jclass cls;
- jmethodID mid;
jbyteArray ary;
- jstring enc;
-
+ jclass cls = GetLauncherHelperClass(env);
+ NULL_CHECK0(cls);
if (s == NULL)
return 0;
- enc = getPlatformEncoding(env);
ary = (*env)->NewByteArray(env, len);
if (ary != 0) {
jstring str = 0;
(*env)->SetByteArrayRegion(env, ary, 0, len, (jbyte *)s);
if (!(*env)->ExceptionOccurred(env)) {
- NULL_CHECK0(cls = FindBootStrapClass(env, "java/lang/String"));
- if (isEncodingSupported(env, enc) == JNI_TRUE) {
- NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "<init>",
- "([BLjava/lang/String;)V"));
- str = (*env)->NewObject(env, cls, mid, ary, enc);
- } else {
- /*If the encoding specified in sun.jnu.encoding is not
- endorsed by "Charset.isSupported" we have to fall back
- to use String(byte[]) explicitly here without specifying
- the encoding name, in which the StringCoding class will
- pickup the iso-8859-1 as the fallback converter for us.
- */
- NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "<init>",
- "([B)V"));
- str = (*env)->NewObject(env, cls, mid, ary);
+ if (makePlatformStringMID == NULL) {
+ NULL_CHECK0(makePlatformStringMID = (*env)->GetStaticMethodID(env,
+ cls, "makePlatformString", "(Z[B)Ljava/lang/String;"));
}
+ str = (*env)->CallStaticObjectMethod(env, cls,
+ makePlatformStringMID, USE_STDERR, ary);
(*env)->DeleteLocalRef(env, ary);
return str;
}
@@ -1239,20 +1211,28 @@
static jclass
LoadMainClass(JNIEnv *env, int mode, char *name)
{
- jclass cls;
jmethodID mid;
jstring str;
jobject result;
jlong start, end;
-
+ jclass cls = GetLauncherHelperClass(env);
+ NULL_CHECK0(cls);
if (JLI_IsTraceLauncher()) {
start = CounterGet();
}
- NULL_CHECK0(cls = FindBootStrapClass(env, "sun/launcher/LauncherHelper"));
- NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls, "checkAndLoadMain",
- "(ZILjava/lang/String;)Ljava/lang/Class;"));
- str = (*env)->NewStringUTF(env, name);
- result = (*env)->CallStaticObjectMethod(env, cls, mid, JNI_TRUE, mode, str);
+ NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls,
+ "checkAndLoadMain",
+ "(ZILjava/lang/String;)Ljava/lang/Class;"));
+
+ switch (mode) {
+ case LM_CLASS:
+ str = NewPlatformString(env, name);
+ break;
+ default:
+ str = (*env)->NewStringUTF(env, name);
+ break;
+ }
+ result = (*env)->CallStaticObjectMethod(env, cls, mid, USE_STDERR, mode, str);
if (JLI_IsTraceLauncher()) {
end = CounterGet();
@@ -1478,15 +1458,15 @@
static void
ShowSettings(JNIEnv *env, char *optString)
{
- jclass cls;
jmethodID showSettingsID;
jstring joptString;
- NULL_CHECK(cls = FindBootStrapClass(env, "sun/launcher/LauncherHelper"));
+ jclass cls = GetLauncherHelperClass(env);
+ NULL_CHECK(cls);
NULL_CHECK(showSettingsID = (*env)->GetStaticMethodID(env, cls,
"showSettings", "(ZLjava/lang/String;JJJZ)V"));
joptString = (*env)->NewStringUTF(env, optString);
(*env)->CallStaticVoidMethod(env, cls, showSettingsID,
- JNI_TRUE,
+ USE_STDERR,
joptString,
(jlong)initialHeapSize,
(jlong)maxHeapSize,
@@ -1500,18 +1480,15 @@
static void
PrintUsage(JNIEnv* env, jboolean doXUsage)
{
- jclass cls;
jmethodID initHelp, vmSelect, vmSynonym, vmErgo, printHelp, printXUsageMessage;
jstring jprogname, vm1, vm2;
int i;
-
- NULL_CHECK(cls = FindBootStrapClass(env, "sun/launcher/LauncherHelper"));
-
-
+ jclass cls = GetLauncherHelperClass(env);
+ NULL_CHECK(cls);
if (doXUsage) {
NULL_CHECK(printXUsageMessage = (*env)->GetStaticMethodID(env, cls,
"printXUsageMessage", "(Z)V"));
- (*env)->CallStaticVoidMethod(env, cls, printXUsageMessage, JNI_TRUE);
+ (*env)->CallStaticVoidMethod(env, cls, printXUsageMessage, USE_STDERR);
} else {
NULL_CHECK(initHelp = (*env)->GetStaticMethodID(env, cls,
"initHelpMessage", "(Ljava/lang/String;)V"));
@@ -1570,7 +1547,7 @@
}
/* Complete the usage message and print to stderr*/
- (*env)->CallStaticVoidMethod(env, cls, printHelp, JNI_TRUE);
+ (*env)->CallStaticVoidMethod(env, cls, printHelp, USE_STDERR);
}
return;
}
--- a/jdk/src/share/classes/com/sun/java/util/jar/pack/BandStructure.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/com/sun/java/util/jar/pack/BandStructure.java Mon Mar 21 16:57:18 2011 -0700
@@ -743,24 +743,24 @@
private void dumpBand() throws IOException {
assert(optDumpBands);
- PrintStream ps = new PrintStream(getDumpStream(this, ".txt"));
- String irr = (bandCoding == regularCoding) ? "" : " irregular";
- ps.print("# length="+length+
- " size="+outputSize()+
- irr+" coding="+bandCoding);
- if (metaCoding != noMetaCoding) {
- StringBuffer sb = new StringBuffer();
- for (int i = 0; i < metaCoding.length; i++) {
- if (i == 1) sb.append(" /");
- sb.append(" ").append(metaCoding[i] & 0xFF);
+ try (PrintStream ps = new PrintStream(getDumpStream(this, ".txt"))) {
+ String irr = (bandCoding == regularCoding) ? "" : " irregular";
+ ps.print("# length="+length+
+ " size="+outputSize()+
+ irr+" coding="+bandCoding);
+ if (metaCoding != noMetaCoding) {
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0; i < metaCoding.length; i++) {
+ if (i == 1) sb.append(" /");
+ sb.append(" ").append(metaCoding[i] & 0xFF);
+ }
+ ps.print(" //header: "+sb);
}
- ps.print(" //header: "+sb);
+ printArrayTo(ps, values, 0, length);
}
- printArrayTo(ps, values, 0, length);
- ps.close();
- OutputStream ds = getDumpStream(this, ".bnd");
- bandCoding.writeArrayTo(ds, values, 0, length);
- ds.close();
+ try (OutputStream ds = getDumpStream(this, ".bnd")) {
+ bandCoding.writeArrayTo(ds, values, 0, length);
+ }
}
/** Disburse one value. */
@@ -829,12 +829,12 @@
private void dumpBand() throws IOException {
assert(optDumpBands);
- OutputStream ds = getDumpStream(this, ".bnd");
- if (bytesForDump != null)
- bytesForDump.writeTo(ds);
- else
- bytes.writeTo(ds);
- ds.close();
+ try (OutputStream ds = getDumpStream(this, ".bnd")) {
+ if (bytesForDump != null)
+ bytesForDump.writeTo(ds);
+ else
+ bytes.writeTo(ds);
+ }
}
public void readDataFrom(InputStream in) throws IOException {
--- a/jdk/src/share/classes/com/sun/java/util/jar/pack/Driver.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/com/sun/java/util/jar/pack/Driver.java Mon Mar 21 16:57:18 2011 -0700
@@ -150,12 +150,12 @@
// See if there is any other action to take.
if ("--config-file=".equals(state)) {
String propFile = av.remove(0);
- InputStream propIn = new FileInputStream(propFile);
Properties fileProps = new Properties();
- fileProps.load(new BufferedInputStream(propIn));
+ try (InputStream propIn = new FileInputStream(propFile)) {
+ fileProps.load(propIn);
+ }
if (engProps.get(verboseProp) != null)
fileProps.list(System.out);
- propIn.close();
for (Map.Entry<Object,Object> me : fileProps.entrySet()) {
engProps.put((String) me.getKey(), (String) me.getValue());
}
@@ -348,10 +348,10 @@
else
fileOut = new FileOutputStream(outfile);
fileOut = new BufferedOutputStream(fileOut);
- JarOutputStream out = new JarOutputStream(fileOut);
- junpack.unpack(in, out);
- //in.close(); // p200 closes in but not out
- out.close();
+ try (JarOutputStream out = new JarOutputStream(fileOut)) {
+ junpack.unpack(in, out);
+ // p200 closes in but not out
+ }
// At this point, we have a good jarfile (or newfile, if -r)
}
@@ -411,8 +411,7 @@
long filelen = new File(jarfile).length();
if (filelen <= 0) return "";
long skiplen = Math.max(0, filelen - tail.length);
- InputStream in = new FileInputStream(new File(jarfile));
- try {
+ try (InputStream in = new FileInputStream(new File(jarfile))) {
in.skip(skiplen);
in.read(tail);
for (int i = tail.length-4; i >= 0; i--) {
@@ -426,8 +425,6 @@
}
}
return "";
- } finally {
- in.close();
}
}
--- a/jdk/src/share/classes/com/sun/java/util/jar/pack/NativeUnpack.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/com/sun/java/util/jar/pack/NativeUnpack.java Mon Mar 21 16:57:18 2011 -0700
@@ -241,9 +241,9 @@
void run(File inFile, JarOutputStream jstream) throws IOException {
// %%% maybe memory-map the file, and pass it straight into unpacker
ByteBuffer mappedFile = null;
- FileInputStream fis = new FileInputStream(inFile);
- run(fis, jstream, mappedFile);
- fis.close();
+ try (FileInputStream fis = new FileInputStream(inFile)) {
+ run(fis, jstream, mappedFile);
+ }
// Note: caller is responsible to finish with jstream.
}
--- a/jdk/src/share/classes/com/sun/java/util/jar/pack/PackageReader.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/com/sun/java/util/jar/pack/PackageReader.java Mon Mar 21 16:57:18 2011 -0700
@@ -540,9 +540,9 @@
Index index = initCPIndex(tag, cpMap);
if (optDumpBands) {
- PrintStream ps = new PrintStream(getDumpStream(index, ".idx"));
- printArrayTo(ps, index.cpMap, 0, index.cpMap.length);
- ps.close();
+ try (PrintStream ps = new PrintStream(getDumpStream(index, ".idx"))) {
+ printArrayTo(ps, index.cpMap, 0, index.cpMap.length);
+ }
}
}
@@ -828,26 +828,27 @@
attr_definition_headers.readFrom(in);
attr_definition_name.readFrom(in);
attr_definition_layout.readFrom(in);
- PrintStream dump = !optDumpBands ? null
- : new PrintStream(getDumpStream(attr_definition_headers, ".def"));
- for (int i = 0; i < numAttrDefs; i++) {
- int header = attr_definition_headers.getByte();
- Utf8Entry name = (Utf8Entry) attr_definition_name.getRef();
- Utf8Entry layout = (Utf8Entry) attr_definition_layout.getRef();
- int ctype = (header & ADH_CONTEXT_MASK);
- int index = (header >> ADH_BIT_SHIFT) - ADH_BIT_IS_LSB;
- Attribute.Layout def = new Attribute.Layout(ctype,
- name.stringValue(),
- layout.stringValue());
- // Check layout string for Java 6 extensions.
- String pvLayout = def.layoutForPackageMajver(getPackageMajver());
- if (!pvLayout.equals(def.layout())) {
- throw new IOException("Bad attribute layout in version 150 archive: "+def.layout());
+ try (PrintStream dump = !optDumpBands ? null
+ : new PrintStream(getDumpStream(attr_definition_headers, ".def")))
+ {
+ for (int i = 0; i < numAttrDefs; i++) {
+ int header = attr_definition_headers.getByte();
+ Utf8Entry name = (Utf8Entry) attr_definition_name.getRef();
+ Utf8Entry layout = (Utf8Entry) attr_definition_layout.getRef();
+ int ctype = (header & ADH_CONTEXT_MASK);
+ int index = (header >> ADH_BIT_SHIFT) - ADH_BIT_IS_LSB;
+ Attribute.Layout def = new Attribute.Layout(ctype,
+ name.stringValue(),
+ layout.stringValue());
+ // Check layout string for Java 6 extensions.
+ String pvLayout = def.layoutForPackageMajver(getPackageMajver());
+ if (!pvLayout.equals(def.layout())) {
+ throw new IOException("Bad attribute layout in version 150 archive: "+def.layout());
+ }
+ this.setAttributeLayoutIndex(def, index);
+ if (dump != null) dump.println(index+" "+def);
}
- this.setAttributeLayoutIndex(def, index);
- if (dump != null) dump.println(index+" "+def);
}
- if (dump != null) dump.close();
attr_definition_headers.doneDisbursing();
attr_definition_name.doneDisbursing();
attr_definition_layout.doneDisbursing();
--- a/jdk/src/share/classes/com/sun/java/util/jar/pack/PackageWriter.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/com/sun/java/util/jar/pack/PackageWriter.java Mon Mar 21 16:57:18 2011 -0700
@@ -458,9 +458,9 @@
Utils.log.info("Writing "+cpMap.length+" "+ConstantPool.tagName(tag)+" entries...");
if (optDumpBands) {
- PrintStream ps = new PrintStream(getDumpStream(index, ".idx"));
- printArrayTo(ps, cpMap, 0, cpMap.length);
- ps.close();
+ try (PrintStream ps = new PrintStream(getDumpStream(index, ".idx"))) {
+ printArrayTo(ps, cpMap, 0, cpMap.length);
+ }
}
switch (tag) {
@@ -923,33 +923,34 @@
}
});
attrDefsWritten = new Attribute.Layout[numAttrDefs];
- PrintStream dump = !optDumpBands ? null
- : new PrintStream(getDumpStream(attr_definition_headers, ".def"));
- int[] indexForDebug = Arrays.copyOf(attrIndexLimit, ATTR_CONTEXT_LIMIT);
- for (int i = 0; i < defs.length; i++) {
- int header = ((Integer)defs[i][0]).intValue();
- Attribute.Layout def = (Attribute.Layout) defs[i][1];
- attrDefsWritten[i] = def;
- assert((header & ADH_CONTEXT_MASK) == def.ctype());
- attr_definition_headers.putByte(header);
- attr_definition_name.putRef(ConstantPool.getUtf8Entry(def.name()));
- String layout = def.layoutForPackageMajver(getPackageMajver());
- attr_definition_layout.putRef(ConstantPool.getUtf8Entry(layout));
- // Check that we are transmitting that correct attribute index:
- boolean debug = false;
- assert(debug = true);
- if (debug) {
- int hdrIndex = (header >> ADH_BIT_SHIFT) - ADH_BIT_IS_LSB;
- if (hdrIndex < 0) hdrIndex = indexForDebug[def.ctype()]++;
- int realIndex = (attrIndexTable.get(def)).intValue();
- assert(hdrIndex == realIndex);
- }
- if (dump != null) {
- int index = (header >> ADH_BIT_SHIFT) - ADH_BIT_IS_LSB;
- dump.println(index+" "+def);
+ try (PrintStream dump = !optDumpBands ? null
+ : new PrintStream(getDumpStream(attr_definition_headers, ".def")))
+ {
+ int[] indexForDebug = Arrays.copyOf(attrIndexLimit, ATTR_CONTEXT_LIMIT);
+ for (int i = 0; i < defs.length; i++) {
+ int header = ((Integer)defs[i][0]).intValue();
+ Attribute.Layout def = (Attribute.Layout) defs[i][1];
+ attrDefsWritten[i] = def;
+ assert((header & ADH_CONTEXT_MASK) == def.ctype());
+ attr_definition_headers.putByte(header);
+ attr_definition_name.putRef(ConstantPool.getUtf8Entry(def.name()));
+ String layout = def.layoutForPackageMajver(getPackageMajver());
+ attr_definition_layout.putRef(ConstantPool.getUtf8Entry(layout));
+ // Check that we are transmitting that correct attribute index:
+ boolean debug = false;
+ assert(debug = true);
+ if (debug) {
+ int hdrIndex = (header >> ADH_BIT_SHIFT) - ADH_BIT_IS_LSB;
+ if (hdrIndex < 0) hdrIndex = indexForDebug[def.ctype()]++;
+ int realIndex = (attrIndexTable.get(def)).intValue();
+ assert(hdrIndex == realIndex);
+ }
+ if (dump != null) {
+ int index = (header >> ADH_BIT_SHIFT) - ADH_BIT_IS_LSB;
+ dump.println(index+" "+def);
+ }
}
}
- if (dump != null) dump.close();
}
void writeAttrCounts() throws IOException {
--- a/jdk/src/share/classes/com/sun/java/util/jar/pack/PropMap.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/com/sun/java/util/jar/pack/PropMap.java Mon Mar 21 16:57:18 2011 -0700
@@ -122,26 +122,23 @@
// Define certain attribute layouts by default.
// Do this after the previous props are put in place,
// to allow override if necessary.
- InputStream propStr = null;
- try {
- String propFile = "intrinsic.properties";
- propStr = PackerImpl.class.getResourceAsStream(propFile);
- props.load(new BufferedInputStream(propStr));
- for (Map.Entry<Object, Object> e : props.entrySet()) {
- String key = (String) e.getKey();
- String val = (String) e.getValue();
- if (key.startsWith("attribute.")) {
- e.setValue(Attribute.normalizeLayoutString(val));
- }
+ String propFile = "intrinsic.properties";
+
+ try (InputStream propStr = PackerImpl.class.getResourceAsStream(propFile)) {
+ if (propStr == null) {
+ throw new RuntimeException(propFile + " cannot be loaded");
}
+ props.load(propStr);
} catch (IOException ee) {
throw new RuntimeException(ee);
- } finally {
- try {
- if (propStr != null) {
- propStr.close();
- }
- } catch (IOException ignore) {}
+ }
+
+ for (Map.Entry<Object, Object> e : props.entrySet()) {
+ String key = (String) e.getKey();
+ String val = (String) e.getValue();
+ if (key.startsWith("attribute.")) {
+ e.setValue(Attribute.normalizeLayoutString(val));
+ }
}
defaultProps = (new HashMap<>(props)); // shrink to fit
--- a/jdk/src/share/classes/com/sun/java/util/jar/pack/UnpackerImpl.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/com/sun/java/util/jar/pack/UnpackerImpl.java Mon Mar 21 16:57:18 2011 -0700
@@ -161,8 +161,9 @@
}
// Use the stream-based implementation.
// %%% Reconsider if native unpacker learns to memory-map the file.
- FileInputStream instr = new FileInputStream(in);
- unpack(instr, out);
+ try (FileInputStream instr = new FileInputStream(in)) {
+ unpack(instr, out);
+ }
if (props.getBoolean(Utils.UNPACK_REMOVE_PACKFILE)) {
in.delete();
}
--- a/jdk/src/share/classes/com/sun/java/util/jar/pack/Utils.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/com/sun/java/util/jar/pack/Utils.java Mon Mar 21 16:57:18 2011 -0700
@@ -268,18 +268,18 @@
// 4947205 : Peformance is slow when using pack-effort=0
out = new BufferedOutputStream(out);
out = new NonCloser(out); // protect from JarOutputStream.close()
- JarOutputStream jout = new JarOutputStream(out);
- copyJarFile(in, jout);
- jout.close();
+ try (JarOutputStream jout = new JarOutputStream(out)) {
+ copyJarFile(in, jout);
+ }
}
static void copyJarFile(JarFile in, OutputStream out) throws IOException {
// 4947205 : Peformance is slow when using pack-effort=0
out = new BufferedOutputStream(out);
out = new NonCloser(out); // protect from JarOutputStream.close()
- JarOutputStream jout = new JarOutputStream(out);
- copyJarFile(in, jout);
- jout.close();
+ try (JarOutputStream jout = new JarOutputStream(out)) {
+ copyJarFile(in, jout);
+ }
}
// Wrapper to prevent closing of client-supplied stream.
static private
--- a/jdk/src/share/classes/com/sun/script/javascript/RhinoScriptEngine.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/com/sun/script/javascript/RhinoScriptEngine.java Mon Mar 21 16:57:18 2011 -0700
@@ -115,6 +115,31 @@
//construct object used to implement getInterface
implementor = new InterfaceImplementor(this) {
+ protected boolean isImplemented(Object thiz, Class<?> iface) {
+ Context cx = enterContext();
+ try {
+ if (thiz != null && !(thiz instanceof Scriptable)) {
+ thiz = cx.toObject(thiz, topLevel);
+ }
+ Scriptable engineScope = getRuntimeScope(context);
+ Scriptable localScope = (thiz != null)? (Scriptable) thiz :
+ engineScope;
+ for (Method method : iface.getMethods()) {
+ // ignore methods of java.lang.Object class
+ if (method.getDeclaringClass() == Object.class) {
+ continue;
+ }
+ Object obj = ScriptableObject.getProperty(localScope, method.getName());
+ if (! (obj instanceof Function)) {
+ return false;
+ }
+ }
+ return true;
+ } finally {
+ cx.exit();
+ }
+ }
+
protected Object convertResult(Method method, Object res)
throws ScriptException {
Class desiredType = method.getReturnType();
--- a/jdk/src/share/classes/com/sun/script/util/InterfaceImplementor.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/com/sun/script/util/InterfaceImplementor.java Mon Mar 21 16:57:18 2011 -0700
@@ -82,12 +82,19 @@
if (iface == null || !iface.isInterface()) {
throw new IllegalArgumentException("interface Class expected");
}
+ if (! isImplemented(thiz, iface)) {
+ return null;
+ }
AccessControlContext accCtxt = AccessController.getContext();
return iface.cast(Proxy.newProxyInstance(iface.getClassLoader(),
new Class[]{iface},
new InterfaceImplementorInvocationHandler(thiz, accCtxt)));
}
+ protected boolean isImplemented(Object thiz, Class<?> iface) {
+ return true;
+ }
+
// called to convert method result after invoke
protected Object convertResult(Method method, Object res)
throws ScriptException {
--- a/jdk/src/share/classes/java/lang/AutoCloseable.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/lang/AutoCloseable.java Mon Mar 21 16:57:18 2011 -0700
@@ -34,12 +34,27 @@
public interface AutoCloseable {
/**
* Closes this resource, relinquishing any underlying resources.
- * This method is invoked automatically by the {@code
- * try}-with-resources statement.
+ * This method is invoked automatically on objects managed by the
+ * {@code try}-with-resources statement.
+ *
+ * <p>While this interface method is declared to throw {@code
+ * Exception}, implementers are <em>strongly</em> encouraged to
+ * declare concrete implementations of the {@code close} method to
+ * throw more specific exceptions, or to throw no exception at all
+ * if the close operation cannot fail.
*
- * <p>Classes implementing this method are strongly encouraged to
- * be declared to throw more specific exceptions (or no exception
- * at all, if the close cannot fail).
+ * <p><em>Implementers of this interface are also strongly advised
+ * to not have the {@code close} method throw {@link
+ * InterruptedException}.</em>
+ *
+ * This exception interacts with a thread's interrupted status,
+ * and runtime misbehavior is likely to occur if an {@code
+ * InterruptedException} is {@linkplain Throwable#addSuppressed
+ * suppressed}.
+ *
+ * More generally, if it would cause problems for an
+ * exception to be suppressed, the {@code AutoCloseable.close}
+ * method should not throw it.
*
* <p>Note that unlike the {@link java.io.Closeable#close close}
* method of {@link java.io.Closeable}, this {@code close} method
@@ -48,9 +63,8 @@
* visible side effect, unlike {@code Closeable.close} which is
* required to have no effect if called more than once.
*
- * However, while not required to be idempotent, implementers of
- * this interface are strongly encouraged to make their {@code
- * close} methods idempotent.
+ * However, implementers of this interface are strongly encouraged
+ * to make their {@code close} methods idempotent.
*
* @throws Exception if this resource cannot be closed
*/
--- a/jdk/src/share/classes/java/lang/ClassLoader.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/lang/ClassLoader.java Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -1626,20 +1626,28 @@
* @since 1.2
*/
protected Package getPackage(String name) {
+ Package pkg;
synchronized (packages) {
- Package pkg = packages.get(name);
- if (pkg == null) {
- if (parent != null) {
- pkg = parent.getPackage(name);
- } else {
- pkg = Package.getSystemPackage(name);
- }
- if (pkg != null) {
- packages.put(name, pkg);
+ pkg = packages.get(name);
+ }
+ if (pkg == null) {
+ if (parent != null) {
+ pkg = parent.getPackage(name);
+ } else {
+ pkg = Package.getSystemPackage(name);
+ }
+ if (pkg != null) {
+ synchronized (packages) {
+ Package pkg2 = packages.get(name);
+ if (pkg2 == null) {
+ packages.put(name, pkg);
+ } else {
+ pkg = pkg2;
+ }
}
}
- return pkg;
}
+ return pkg;
}
/**
--- a/jdk/src/share/classes/java/net/URI.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/net/URI.java Mon Mar 21 16:57:18 2011 -0700
@@ -1829,21 +1829,23 @@
} else if (authority != null) {
sb.append("//");
if (authority.startsWith("[")) {
+ // authority should (but may not) contain an embedded IPv6 address
int end = authority.indexOf("]");
- if (end != -1 && authority.indexOf(":")!=-1) {
- String doquote, dontquote;
+ String doquote = authority, dontquote = "";
+ if (end != -1 && authority.indexOf(":") != -1) {
+ // the authority contains an IPv6 address
if (end == authority.length()) {
dontquote = authority;
doquote = "";
} else {
- dontquote = authority.substring(0,end+1);
- doquote = authority.substring(end+1);
+ dontquote = authority.substring(0 , end + 1);
+ doquote = authority.substring(end + 1);
}
- sb.append (dontquote);
- sb.append(quote(doquote,
+ }
+ sb.append(dontquote);
+ sb.append(quote(doquote,
L_REG_NAME | L_SERVER,
H_REG_NAME | H_SERVER));
- }
} else {
sb.append(quote(authority,
L_REG_NAME | L_SERVER,
--- a/jdk/src/share/classes/java/net/URLConnection.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/net/URLConnection.java Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -1422,7 +1422,7 @@
if (!is.markSupported())
return null;
- is.mark(12);
+ is.mark(16);
int c1 = is.read();
int c2 = is.read();
int c3 = is.read();
@@ -1434,6 +1434,11 @@
int c9 = is.read();
int c10 = is.read();
int c11 = is.read();
+ int c12 = is.read();
+ int c13 = is.read();
+ int c14 = is.read();
+ int c15 = is.read();
+ int c16 = is.read();
is.reset();
if (c1 == 0xCA && c2 == 0xFE && c3 == 0xBA && c4 == 0xBE) {
@@ -1461,6 +1466,13 @@
}
}
+ // big and little (identical) endian UTF-8 encodings, with BOM
+ if (c1 == 0xef && c2 == 0xbb && c3 == 0xbf) {
+ if (c4 == '<' && c5 == '?' && c6 == 'x') {
+ return "application/xml";
+ }
+ }
+
// big and little endian UTF-16 encodings, with byte order mark
if (c1 == 0xfe && c2 == 0xff) {
if (c3 == 0 && c4 == '<' && c5 == 0 && c6 == '?' &&
@@ -1476,6 +1488,23 @@
}
}
+ // big and little endian UTF-32 encodings, with BOM
+ if (c1 == 0x00 && c2 == 0x00 && c3 == 0xfe && c4 == 0xff) {
+ if (c5 == 0 && c6 == 0 && c7 == 0 && c8 == '<' &&
+ c9 == 0 && c10 == 0 && c11 == 0 && c12 == '?' &&
+ c13 == 0 && c14 == 0 && c15 == 0 && c16 == 'x') {
+ return "application/xml";
+ }
+ }
+
+ if (c1 == 0xff && c2 == 0xfe && c3 == 0x00 && c4 == 0x00) {
+ if (c5 == '<' && c6 == 0 && c7 == 0 && c8 == 0 &&
+ c9 == '?' && c10 == 0 && c11 == 0 && c12 == 0 &&
+ c13 == 'x' && c14 == 0 && c15 == 0 && c16 == 0) {
+ return "application/xml";
+ }
+ }
+
if (c1 == 'G' && c2 == 'I' && c3 == 'F' && c4 == '8') {
return "image/gif";
}
--- a/jdk/src/share/classes/java/nio/file/Files.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/nio/file/Files.java Mon Mar 21 16:57:18 2011 -0700
@@ -1712,10 +1712,10 @@
* @return the {@code path} parameter
*
* @throws UnsupportedOperationException
- * if the attribute view is not available or it does not support
- * updating the attribute
+ * if the attribute view is not available
* @throws IllegalArgumentException
- * if the attribute value is of the correct type but has an
+ * if the attribute name is not specified, or is not recognized, or
+ * the attribute value is of the correct type but has an
* inappropriate value
* @throws ClassCastException
* if the attribute value is not of the expected type or is a
@@ -1776,9 +1776,12 @@
* @param options
* options indicating how symbolic links are handled
*
- * @return the attribute value or {@code null} if the attribute view
- * is not available or it does not support reading the attribute
+ * @return the attribute value
*
+ * @throws UnsupportedOperationException
+ * if the attribute view is not available
+ * @throws IllegalArgumentException
+ * if the attribute name is not specified or is not recognized
* @throws IOException
* if an I/O error occurs
* @throws SecurityException
@@ -1794,8 +1797,9 @@
{
// only one attribute should be read
if (attribute.indexOf('*') >= 0 || attribute.indexOf(',') >= 0)
- return null;
+ throw new IllegalArgumentException(attribute);
Map<String,Object> map = readAttributes(path, attribute, options);
+ assert map.size() == 1;
String name;
int pos = attribute.indexOf(':');
if (pos == -1) {
@@ -1868,9 +1872,14 @@
* @param options
* options indicating how symbolic links are handled
*
- * @return a map of the attributes returned; may be empty. The map's keys
- * are the attribute names, its values are the attribute values
+ * @return a map of the attributes returned; The map's keys are the
+ * attribute names, its values are the attribute values
*
+ * @throws UnsupportedOperationException
+ * if the attribute view is not available
+ * @throws IllegalArgumentException
+ * if no attributes are specified or an unrecognized attributes is
+ * specified
* @throws IOException
* if an I/O error occurs
* @throws SecurityException
--- a/jdk/src/share/classes/java/nio/file/Path.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/nio/file/Path.java Mon Mar 21 16:57:18 2011 -0700
@@ -228,6 +228,9 @@
* not have a root component and the given path has a root component then
* this path does not start with the given path.
*
+ * <p> If the given path is associated with a different {@code FileSystem}
+ * to this path then {@code false} is returned.
+ *
* @param other
* the given path
*
@@ -270,6 +273,9 @@
* does not have a root component and the given path has a root component
* then this path does not end with the given path.
*
+ * <p> If the given path is associated with a different {@code FileSystem}
+ * to this path then {@code false} is returned.
+ *
* @param other
* the given path
*
@@ -283,7 +289,10 @@
* the given path string, in exactly the manner specified by the {@link
* #endsWith(Path) endsWith(Path)} method. On UNIX for example, the path
* "{@code foo/bar}" ends with "{@code foo/bar}" and "{@code bar}". It does
- * not end with "{@code r}" or "{@code /bar}".
+ * not end with "{@code r}" or "{@code /bar}". Note that trailing separators
+ * are not taken into account, and so invoking this method on the {@code
+ * Path}"{@code foo/bar}" with the {@code String} "{@code bar/}" returns
+ * {@code true}.
*
* @param other
* the given path string
@@ -724,12 +733,18 @@
* provider, platform specific. This method does not access the file system
* and neither file is required to exist.
*
+ * <p> This method may not be used to compare paths that are associated
+ * with different file system providers.
+ *
* @param other the path compared to this path.
*
* @return zero if the argument is {@link #equals equal} to this path, a
* value less than zero if this path is lexicographically less than
* the argument, or a value greater than zero if this path is
* lexicographically greater than the argument
+ *
+ * @throws ClassCastException
+ * if the paths are associated with different providers
*/
@Override
int compareTo(Path other);
@@ -738,7 +753,7 @@
* Tests this path for equality with the given object.
*
* <p> If the given object is not a Path, or is a Path associated with a
- * different provider, then this method immediately returns {@code false}.
+ * different {@code FileSystem}, then this method returns {@code false}.
*
* <p> Whether or not two path are equal depends on the file system
* implementation. In some cases the paths are compared without regard
--- a/jdk/src/share/classes/java/nio/file/WatchKey.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/nio/file/WatchKey.java Mon Mar 21 16:57:18 2011 -0700
@@ -146,5 +146,5 @@
*
* @return the object for which this watch key was created
*/
- //T watchable();
+ Watchable watchable();
}
--- a/jdk/src/share/classes/java/nio/file/attribute/FileTime.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/nio/file/attribute/FileTime.java Mon Mar 21 16:57:18 2011 -0700
@@ -216,12 +216,14 @@
* "2009-02-13T23:31:30Z"}, and {@code FileTime.fromMillis(1234567890123L).toString()}
* yields {@code "2009-02-13T23:31:30.123Z"}.
*
- * <p> A {@code FileTime} is primarly intended to represent the value of a
+ * <p> A {@code FileTime} is primarily intended to represent the value of a
* file's time stamp. Where used to represent <i>extreme values</i>, where
* the year is less than "{@code 0001}" or greater than "{@code 9999}" then
- * the year may be expanded to more than four digits and may be
- * negative-signed. If more than four digits then leading zeros are not
- * present. The year before "{@code 0001}" is "{@code -0001}".
+ * this method deviates from ISO 8601 in the same manner as the
+ * <a href="http://www.w3.org/TR/xmlschema-2/#deviantformats">XML Schema
+ * language</a>. That is, the year may be expanded to more than four digits
+ * and may be negative-signed. If more than four digits then leading zeros
+ * are not present. The year before "{@code 0001}" is "{@code -0001}".
*
* @return the string representation of this file time
*/
--- a/jdk/src/share/classes/java/nio/file/spi/FileSystemProvider.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/nio/file/spi/FileSystemProvider.java Mon Mar 21 16:57:18 2011 -0700
@@ -1037,6 +1037,11 @@
* @return a map of the attributes returned; may be empty. The map's keys
* are the attribute names, its values are the attribute values
*
+ * @throws UnsupportedOperationException
+ * if the attribute view is not available
+ * @throws IllegalArgumentException
+ * if no attributes are specified or an unrecognized attributes is
+ * specified
* @throws IOException
* If an I/O error occurs
* @throws SecurityException
@@ -1064,10 +1069,10 @@
* options indicating how symbolic links are handled
*
* @throws UnsupportedOperationException
- * if the attribute view is not available or it does not support
- * updating the attribute
+ * if the attribute view is not available
* @throws IllegalArgumentException
- * if the attribute value is of the correct type but has an
+ * if the attribute name is not specified, or is not recognized, or
+ * the attribute value is of the correct type but has an
* inappropriate value
* @throws ClassCastException
* If the attribute value is not of the expected type or is a
--- a/jdk/src/share/classes/java/security/CodeSource.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/security/CodeSource.java Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -578,7 +578,7 @@
// Deserialize array of code signers (if any)
try {
- this.signers = (CodeSigner[])ois.readObject();
+ this.signers = ((CodeSigner[])ois.readObject()).clone();
} catch (IOException ioe) {
// no signers present
}
--- a/jdk/src/share/classes/java/security/Timestamp.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/security/Timestamp.java Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -157,7 +157,8 @@
// Explicitly reset hash code value to -1
private void readObject(ObjectInputStream ois)
throws IOException, ClassNotFoundException {
- ois.defaultReadObject();
- myhash = -1;
+ ois.defaultReadObject();
+ myhash = -1;
+ timestamp = new Date(timestamp.getTime());
}
}
--- a/jdk/src/share/classes/java/sql/DriverManager.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/sql/DriverManager.java Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -26,10 +26,10 @@
package java.sql;
import java.util.Iterator;
-import java.sql.Driver;
import java.util.ServiceLoader;
import java.security.AccessController;
import java.security.PrivilegedAction;
+import java.util.concurrent.CopyOnWriteArrayList;
/**
@@ -79,6 +79,27 @@
public class DriverManager {
+ // List of registered JDBC drivers
+ private final static CopyOnWriteArrayList<Driver> registeredDrivers = new CopyOnWriteArrayList<Driver>();
+ private static volatile int loginTimeout = 0;
+ private static volatile java.io.PrintWriter logWriter = null;
+ private static volatile java.io.PrintStream logStream = null;
+ // Used in println() to synchronize logWriter
+ private final static Object logSync = new Object();
+
+ /* Prevent the DriverManager class from being instantiated. */
+ private DriverManager(){}
+
+
+ /**
+ * Load the initial JDBC drivers by checking the System property
+ * jdbc.properties and then use the {@code ServiceLoader} mechanism
+ */
+ static {
+ loadInitialDrivers();
+ println("JDBC DriverManager initialized");
+ }
+
/**
* The <code>SQLPermission</code> constant that allows the
* setting of the logging stream.
@@ -235,44 +256,33 @@
*/
public static Driver getDriver(String url)
throws SQLException {
- java.util.Vector drivers = null;
println("DriverManager.getDriver(\"" + url + "\")");
- if (!initialized) {
- initialize();
- }
-
- synchronized (DriverManager.class){
- // use the read copy of the drivers vector
- drivers = readDrivers;
- }
-
// Gets the classloader of the code that called this method, may
// be null.
ClassLoader callerCL = DriverManager.getCallerClassLoader();
- // Walk through the loaded drivers attempting to locate someone
+ // Walk through the loaded registeredDrivers attempting to locate someone
// who understands the given URL.
- for (int i = 0; i < drivers.size(); i++) {
- DriverInfo di = (DriverInfo)drivers.elementAt(i);
+ for (Driver aDriver : registeredDrivers) {
// If the caller does not have permission to load the driver then
// skip it.
- if ( getCallerClass(callerCL, di.driverClassName ) !=
- di.driverClass ) {
- println(" skipping: " + di);
- continue;
+ if(isDriverAllowed(aDriver, callerCL)) {
+ try {
+ if(aDriver.acceptsURL(url)) {
+ // Success!
+ println("getDriver returning " + aDriver.getClass().getName());
+ return (aDriver);
+ }
+
+ } catch(SQLException sqe) {
+ // Drop through and try the next driver.
+ }
+ } else {
+ println(" skipping: " + aDriver.getClass().getName());
}
- try {
- println(" trying " + di);
- if (di.driver.acceptsURL(url)) {
- // Success!
- println("getDriver returning " + di);
- return (di.driver);
- }
- } catch (SQLException ex) {
- // Drop through and try the next driver.
- }
+
}
println("getDriver: no suitable driver");
@@ -292,23 +302,16 @@
*/
public static synchronized void registerDriver(java.sql.Driver driver)
throws SQLException {
- if (!initialized) {
- initialize();
+
+ /* Register the driver if it has not already been added to our list */
+ if(driver != null) {
+ registeredDrivers.addIfAbsent(driver);
+ } else {
+ // This is for compatibility with the original DriverManager
+ throw new NullPointerException();
}
- DriverInfo di = new DriverInfo();
-
- di.driver = driver;
- di.driverClass = driver.getClass();
- di.driverClassName = di.driverClass.getName();
-
- // Not Required -- drivers.addElement(di);
-
- writeDrivers.addElement(di);
- println("registerDriver: " + di);
-
- /* update the read copy of drivers vector */
- readDrivers = (java.util.Vector) writeDrivers.clone();
+ println("registerDriver: " + driver);
}
@@ -321,37 +324,26 @@
*/
public static synchronized void deregisterDriver(Driver driver)
throws SQLException {
+ if (driver == null) {
+ return;
+ }
+
// Gets the classloader of the code that called this method,
// may be null.
ClassLoader callerCL = DriverManager.getCallerClassLoader();
println("DriverManager.deregisterDriver: " + driver);
- // Walk through the loaded drivers.
- int i;
- DriverInfo di = null;
- for (i = 0; i < writeDrivers.size(); i++) {
- di = (DriverInfo)writeDrivers.elementAt(i);
- if (di.driver == driver) {
- break;
+ if(registeredDrivers.contains(driver)) {
+ if (isDriverAllowed(driver, callerCL)) {
+ registeredDrivers.remove(driver);
+ } else {
+ // If the caller does not have permission to load the driver then
+ // throw a SecurityException.
+ throw new SecurityException();
}
- }
- // If we can't find the driver just return.
- if (i >= writeDrivers.size()) {
+ } else {
println(" couldn't find driver to unload");
- return;
}
-
- // If the caller does not have permission to load the driver then
- // throw a security exception.
- if (getCallerClass(callerCL, di.driverClassName ) != di.driverClass ) {
- throw new SecurityException();
- }
-
- // Remove the driver. Other entries in drivers get shuffled down.
- writeDrivers.removeElementAt(i);
-
- /* update the read copy of drivers vector */
- readDrivers = (java.util.Vector) writeDrivers.clone();
}
/**
@@ -364,34 +356,22 @@
* @return the list of JDBC Drivers loaded by the caller's class loader
*/
public static java.util.Enumeration<Driver> getDrivers() {
- java.util.Vector<Driver> result = new java.util.Vector<>();
- java.util.Vector drivers = null;
-
- if (!initialized) {
- initialize();
- }
-
- synchronized (DriverManager.class){
- // use the readcopy of drivers
- drivers = readDrivers;
- }
+ java.util.Vector<Driver> result = new java.util.Vector<Driver>();
// Gets the classloader of the code that called this method, may
// be null.
ClassLoader callerCL = DriverManager.getCallerClassLoader();
- // Walk through the loaded drivers.
- for (int i = 0; i < drivers.size(); i++) {
- DriverInfo di = (DriverInfo)drivers.elementAt(i);
+ // Walk through the loaded registeredDrivers.
+ for(Driver aDriver : registeredDrivers) {
// If the caller does not have permission to load the driver then
// skip it.
- if ( getCallerClass(callerCL, di.driverClassName ) != di.driverClass ) {
- println(" skipping: " + di);
- continue;
+ if(isDriverAllowed(aDriver, callerCL)) {
+ result.addElement(aDriver);
+ } else {
+ println(" skipping: " + aDriver.getClass().getName());
}
- result.addElement(di.driver);
}
-
return (result.elements());
}
@@ -481,21 +461,22 @@
//------------------------------------------------------------------------
- // Returns the class object that would be created if the code calling the
- // driver manager had loaded the driver class, or null if the class
- // is inaccessible.
- private static Class getCallerClass(ClassLoader callerClassLoader,
- String driverClassName) {
- Class callerC = null;
+ // Indicates whether the class object that would be created if the code calling
+ // DriverManager is accessible.
+ private static boolean isDriverAllowed(Driver driver, ClassLoader classLoader) {
+ boolean result = false;
+ if(driver != null) {
+ Class<?> aClass = null;
+ try {
+ aClass = Class.forName(driver.getClass().getName(), true, classLoader);
+ } catch (Exception ex) {
+ result = false;
+ }
- try {
- callerC = Class.forName(driverClassName, true, callerClassLoader);
- }
- catch (Exception ex) {
- callerC = null; // being very careful
+ result = ( aClass == driver.getClass() ) ? true : false;
}
- return callerC;
+ return result;
}
private static void loadInitialDrivers() {
@@ -544,26 +525,17 @@
});
println("DriverManager.initialize: jdbc.drivers = " + drivers);
- if (drivers == null) {
+
+ if (drivers == null || drivers.equals("")) {
return;
}
- while (drivers.length() != 0) {
- int x = drivers.indexOf(':');
- String driver;
- if (x < 0) {
- driver = drivers;
- drivers = "";
- } else {
- driver = drivers.substring(0, x);
- drivers = drivers.substring(x+1);
- }
- if (driver.length() == 0) {
- continue;
- }
+ String[] driversList = drivers.split(":");
+ println("number of Drivers:" + driversList.length);
+ for (String aDriver : driversList) {
try {
- println("DriverManager.Initialize: loading " + driver);
- Class.forName(driver, true,
- ClassLoader.getSystemClassLoader());
+ println("DriverManager.Initialize: loading " + aDriver);
+ Class.forName(aDriver, true,
+ ClassLoader.getSystemClassLoader());
} catch (Exception ex) {
println("DriverManager.Initialize: load failed: " + ex);
}
@@ -574,7 +546,6 @@
// Worker method called by the public getConnection() methods.
private static Connection getConnection(
String url, java.util.Properties info, ClassLoader callerCL) throws SQLException {
- java.util.Vector drivers = null;
/*
* When callerCl is null, we should check the application's
* (which is invoking this class indirectly)
@@ -594,40 +565,32 @@
println("DriverManager.getConnection(\"" + url + "\")");
- if (!initialized) {
- initialize();
- }
-
- synchronized (DriverManager.class){
- // use the readcopy of drivers
- drivers = readDrivers;
- }
-
- // Walk through the loaded drivers attempting to make a connection.
+ // Walk through the loaded registeredDrivers attempting to make a connection.
// Remember the first exception that gets raised so we can reraise it.
SQLException reason = null;
- for (int i = 0; i < drivers.size(); i++) {
- DriverInfo di = (DriverInfo)drivers.elementAt(i);
+ for(Driver aDriver : registeredDrivers) {
// If the caller does not have permission to load the driver then
// skip it.
- if ( getCallerClass(callerCL, di.driverClassName ) != di.driverClass ) {
- println(" skipping: " + di);
- continue;
+ if(isDriverAllowed(aDriver, callerCL)) {
+ try {
+ println(" trying " + aDriver.getClass().getName());
+ Connection con = aDriver.connect(url, info);
+ if (con != null) {
+ // Success!
+ println("getConnection returning " + aDriver.getClass().getName());
+ return (con);
+ }
+ } catch (SQLException ex) {
+ if (reason == null) {
+ reason = ex;
+ }
+ }
+
+ } else {
+ println(" skipping: " + aDriver.getClass().getName());
}
- try {
- println(" trying " + di);
- Connection result = di.driver.connect(url, info);
- if (result != null) {
- // Success!
- println("getConnection returning " + di);
- return (result);
- }
- } catch (SQLException ex) {
- if (reason == null) {
- reason = ex;
- }
- }
+
}
// if we got here nobody could connect.
@@ -640,45 +603,7 @@
throw new SQLException("No suitable driver found for "+ url, "08001");
}
-
- // Class initialization.
- static void initialize() {
- if (initialized) {
- return;
- }
- initialized = true;
- loadInitialDrivers();
- println("JDBC DriverManager initialized");
- }
-
- /* Prevent the DriverManager class from being instantiated. */
- private DriverManager(){}
-
- /* write copy of the drivers vector */
- private static java.util.Vector writeDrivers = new java.util.Vector();
-
- /* write copy of the drivers vector */
- private static java.util.Vector readDrivers = new java.util.Vector();
-
- private static int loginTimeout = 0;
- private static java.io.PrintWriter logWriter = null;
- private static java.io.PrintStream logStream = null;
- private static boolean initialized = false;
-
- private static Object logSync = new Object();
-
/* Returns the caller's class loader, or null if none */
private static native ClassLoader getCallerClassLoader();
}
-
-// DriverInfo is a package-private support class.
-class DriverInfo {
- Driver driver;
- Class driverClass;
- String driverClassName;
-
- public String toString() {
- return ("driver[className=" + driverClassName + "," + driver + "]");
- }
-}
--- a/jdk/src/share/classes/java/util/Formatter.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/util/Formatter.java Mon Mar 21 16:57:18 2011 -0700
@@ -1401,10 +1401,9 @@
* <p> The number of digits in the result for the fractional part of
* <i>m</i> or <i>a</i> is equal to the precision. If the precision is not
* specified then the default value is {@code 6}. If the precision is
- * less than the number of digits which would appear after the decimal
- * point in the string returned by {@link Float#toString(float)} or {@link
- * Double#toString(double)} respectively, then the value will be rounded
- * using the {@linkplain java.math.BigDecimal#ROUND_HALF_UP round half up
+ * less than the number of digits to the right of the decimal point then
+ * the value will be rounded using the
+ * {@linkplain java.math.BigDecimal#ROUND_HALF_UP round half up
* algorithm}. Otherwise, zeros may be appended to reach the precision.
* For a canonical representation of the value, use {@link
* BigDecimal#toString()}.
@@ -1463,12 +1462,11 @@
* more decimal digits representing the fractional part of <i>m</i>.
*
* <p> The number of digits in the result for the fractional part of
- * <i>m</i> or <i>a</i> is equal to the precision. If the precision is not
+ * <i>m</i> or <i>a</i> is equal to the precision. If the precision is not
* specified then the default value is {@code 6}. If the precision is
- * less than the number of digits which would appear after the decimal
- * point in the string returned by {@link Float#toString(float)} or {@link
- * Double#toString(double)} respectively, then the value will be rounded
- * using the {@linkplain java.math.BigDecimal#ROUND_HALF_UP round half up
+ * less than the number of digits to the right of the decimal point
+ * then the value will be rounded using the
+ * {@linkplain java.math.BigDecimal#ROUND_HALF_UP round half up
* algorithm}. Otherwise, zeros may be appended to reach the precision.
* For a canonical representation of the value, use {@link
* BigDecimal#toString()}.
@@ -3585,7 +3583,7 @@
int scale = value.scale();
if (scale > prec) {
- // more "scale" digits than the requested "precision
+ // more "scale" digits than the requested "precision"
int compPrec = value.precision();
if (compPrec <= scale) {
// case of 0.xxxxxx
--- a/jdk/src/share/classes/java/util/JumboEnumSet.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/util/JumboEnumSet.java Mon Mar 21 16:57:18 2011 -0700
@@ -34,6 +34,8 @@
* @serial exclude
*/
class JumboEnumSet<E extends Enum<E>> extends EnumSet<E> {
+ private static final long serialVersionUID = 334349849919042784L;
+
/**
* Bit vector representation of this set. The ith bit of the jth
* element of this array represents the presence of universe[64*j +i]
@@ -138,8 +140,11 @@
public void remove() {
if (lastReturned == 0)
throw new IllegalStateException();
- elements[lastReturnedIndex] -= lastReturned;
- size--;
+ final long oldElements = elements[lastReturnedIndex];
+ elements[lastReturnedIndex] &= ~lastReturned;
+ if (oldElements != elements[lastReturnedIndex]) {
+ size--;
+ }
lastReturned = 0;
}
}
--- a/jdk/src/share/classes/java/util/Locale.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/util/Locale.java Mon Mar 21 16:57:18 2011 -0700
@@ -1168,7 +1168,7 @@
boolean e = (_extensions.getID().length() != 0);
StringBuilder result = new StringBuilder(_baseLocale.getLanguage());
- if (r || (l && v)) {
+ if (r || (l && (v || s || e))) {
result.append('_')
.append(_baseLocale.getRegion()); // This may just append '_'
}
--- a/jdk/src/share/classes/java/util/RegularEnumSet.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/util/RegularEnumSet.java Mon Mar 21 16:57:18 2011 -0700
@@ -34,6 +34,7 @@
* @serial exclude
*/
class RegularEnumSet<E extends Enum<E>> extends EnumSet<E> {
+ private static final long serialVersionUID = 3411599620347842686L;
/**
* Bit vector representation of this set. The 2^k bit indicates the
* presence of universe[k] in this set.
@@ -106,7 +107,7 @@
public void remove() {
if (lastReturned == 0)
throw new IllegalStateException();
- elements -= lastReturned;
+ elements &= ~lastReturned;
lastReturned = 0;
}
}
--- a/jdk/src/share/classes/java/util/TreeMap.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/util/TreeMap.java Mon Mar 21 16:57:18 2011 -0700
@@ -528,11 +528,8 @@
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {
- // TBD:
- // 5045147: (coll) Adding null to an empty TreeSet should
- // throw NullPointerException
- //
- // compare(key, key); // type check
+ compare(key, key); // type (and possibly null) check
+
root = new Entry<>(key, value, null);
size = 1;
modCount++;
--- a/jdk/src/share/classes/java/util/UUID.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/util/UUID.java Mon Mar 21 16:57:18 2011 -0700
@@ -26,8 +26,6 @@
package java.util;
import java.security.*;
-import java.io.IOException;
-import java.io.UnsupportedEncodingException;
/**
* A class that represents an immutable universally unique identifier (UUID).
@@ -91,36 +89,6 @@
private final long leastSigBits;
/*
- * The version number associated with this UUID. Computed on demand.
- */
- private transient int version = -1;
-
- /*
- * The variant number associated with this UUID. Computed on demand.
- */
- private transient int variant = -1;
-
- /*
- * The timestamp associated with this UUID. Computed on demand.
- */
- private transient volatile long timestamp = -1;
-
- /*
- * The clock sequence associated with this UUID. Computed on demand.
- */
- private transient int sequence = -1;
-
- /*
- * The node number associated with this UUID. Computed on demand.
- */
- private transient long node = -1;
-
- /*
- * The hashcode of this UUID. Computed on demand.
- */
- private transient int hashCode = -1;
-
- /*
* The random number generator used by this class to create random
* based UUIDs.
*/
@@ -134,7 +102,7 @@
private UUID(byte[] data) {
long msb = 0;
long lsb = 0;
- assert data.length == 16;
+ assert data.length == 16 : "data must be 16 bytes in length";
for (int i=0; i<8; i++)
msb = (msb << 8) | (data[i] & 0xff);
for (int i=8; i<16; i++)
@@ -276,11 +244,8 @@
* @return The version number of this {@code UUID}
*/
public int version() {
- if (version < 0) {
- // Version is bits masked by 0x000000000000F000 in MS long
- version = (int)((mostSigBits >> 12) & 0x0f);
- }
- return version;
+ // Version is bits masked by 0x000000000000F000 in MS long
+ return (int)((mostSigBits >> 12) & 0x0f);
}
/**
@@ -298,17 +263,13 @@
* @return The variant number of this {@code UUID}
*/
public int variant() {
- if (variant < 0) {
- // This field is composed of a varying number of bits
- if ((leastSigBits >>> 63) == 0) {
- variant = 0;
- } else if ((leastSigBits >>> 62) == 2) {
- variant = 2;
- } else {
- variant = (int)(leastSigBits >>> 61);
- }
- }
- return variant;
+ // This field is composed of a varying number of bits.
+ // 0 - - Reserved for NCS backward compatibility
+ // 1 0 - The Leach-Salz variant (used by this class)
+ // 1 1 0 Reserved, Microsoft backward compatibility
+ // 1 1 1 Reserved for future definition.
+ return (int) ((leastSigBits >>> (64 - (leastSigBits >>> 62)))
+ & (leastSigBits >> 63));
}
/**
@@ -330,14 +291,10 @@
if (version() != 1) {
throw new UnsupportedOperationException("Not a time-based UUID");
}
- long result = timestamp;
- if (result < 0) {
- result = (mostSigBits & 0x0000000000000FFFL) << 48;
- result |= ((mostSigBits >> 16) & 0xFFFFL) << 32;
- result |= mostSigBits >>> 32;
- timestamp = result;
- }
- return result;
+
+ return (mostSigBits & 0x0FFFL) << 48
+ | ((mostSigBits >> 16) & 0x0FFFFL) << 32
+ | mostSigBits >>> 32;
}
/**
@@ -360,10 +317,8 @@
if (version() != 1) {
throw new UnsupportedOperationException("Not a time-based UUID");
}
- if (sequence < 0) {
- sequence = (int)((leastSigBits & 0x3FFF000000000000L) >>> 48);
- }
- return sequence;
+
+ return (int)((leastSigBits & 0x3FFF000000000000L) >>> 48);
}
/**
@@ -386,10 +341,8 @@
if (version() != 1) {
throw new UnsupportedOperationException("Not a time-based UUID");
}
- if (node < 0) {
- node = leastSigBits & 0x0000FFFFFFFFFFFFL;
- }
- return node;
+
+ return leastSigBits & 0x0000FFFFFFFFFFFFL;
}
// Object Inherited Methods
@@ -438,13 +391,8 @@
* @return A hash code value for this {@code UUID}
*/
public int hashCode() {
- if (hashCode == -1) {
- hashCode = (int)((mostSigBits >> 32) ^
- mostSigBits ^
- (leastSigBits >> 32) ^
- leastSigBits);
- }
- return hashCode;
+ long hilo = mostSigBits ^ leastSigBits;
+ return ((int)(hilo >> 32)) ^ (int) hilo;
}
/**
@@ -460,9 +408,7 @@
* otherwise
*/
public boolean equals(Object obj) {
- if (!(obj instanceof UUID))
- return false;
- if (((UUID)obj).variant() != this.variant())
+ if ((null == obj) || (obj.getClass() != UUID.class))
return false;
UUID id = (UUID)obj;
return (mostSigBits == id.mostSigBits &&
@@ -494,23 +440,4 @@
(this.leastSigBits > val.leastSigBits ? 1 :
0))));
}
-
- /**
- * Reconstitute the {@code UUID} instance from a stream (that is,
- * deserialize it). This is necessary to set the transient fields to their
- * correct uninitialized value so they will be recomputed on demand.
- */
- private void readObject(java.io.ObjectInputStream in)
- throws java.io.IOException, ClassNotFoundException {
-
- in.defaultReadObject();
-
- // Set "cached computation" fields to their initial values
- version = -1;
- variant = -1;
- timestamp = -1;
- sequence = -1;
- node = -1;
- hashCode = -1;
- }
}
--- a/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java Mon Mar 21 16:57:18 2011 -0700
@@ -44,8 +44,8 @@
* creation time, depending on which constructor is used.
*
* <p>This class implements a concurrent variant of <a
- * href="http://www.cs.umd.edu/~pugh/">SkipLists</a> providing
- * expected average <i>log(n)</i> time cost for the
+ * href="http://en.wikipedia.org/wiki/Skip_list" target="_top">SkipLists</a>
+ * providing expected average <i>log(n)</i> time cost for the
* <tt>containsKey</tt>, <tt>get</tt>, <tt>put</tt> and
* <tt>remove</tt> operations and their variants. Insertion, removal,
* update, and access operations safely execute concurrently by
--- a/jdk/src/share/classes/java/util/concurrent/Exchanger.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/util/concurrent/Exchanger.java Mon Mar 21 16:57:18 2011 -0700
@@ -164,8 +164,8 @@
* races between two threads or thread pre-emptions occurring
* between reading and CASing. Also, very transient peak
* contention can be much higher than the average sustainable
- * levels. The max limit is decreased on average 50% of the times
- * that a non-slot-zero wait elapses without being fulfilled.
+ * levels. An attempt to decrease the max limit is usually made
+ * when a non-slot-zero wait elapses without being fulfilled.
* Threads experiencing elapsed waits move closer to zero, so
* eventually find existing (or future) threads even if the table
* has been shrunk due to inactivity. The chosen mechanics and
--- a/jdk/src/share/classes/java/util/concurrent/ForkJoinPool.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/util/concurrent/ForkJoinPool.java Mon Mar 21 16:57:18 2011 -0700
@@ -40,6 +40,7 @@
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Random;
import java.util.concurrent.AbstractExecutorService;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
@@ -51,6 +52,7 @@
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;
+import java.util.concurrent.locks.Condition;
/**
* An {@link ExecutorService} for running {@link ForkJoinTask}s.
@@ -158,239 +160,208 @@
* set of worker threads: Submissions from non-FJ threads enter
* into a submission queue. Workers take these tasks and typically
* split them into subtasks that may be stolen by other workers.
- * The main work-stealing mechanics implemented in class
- * ForkJoinWorkerThread give first priority to processing tasks
- * from their own queues (LIFO or FIFO, depending on mode), then
- * to randomized FIFO steals of tasks in other worker queues, and
- * lastly to new submissions. These mechanics do not consider
- * affinities, loads, cache localities, etc, so rarely provide the
- * best possible performance on a given machine, but portably
- * provide good throughput by averaging over these factors.
- * (Further, even if we did try to use such information, we do not
- * usually have a basis for exploiting it. For example, some sets
- * of tasks profit from cache affinities, but others are harmed by
- * cache pollution effects.)
+ * Preference rules give first priority to processing tasks from
+ * their own queues (LIFO or FIFO, depending on mode), then to
+ * randomized FIFO steals of tasks in other worker queues, and
+ * lastly to new submissions.
+ *
+ * The main throughput advantages of work-stealing stem from
+ * decentralized control -- workers mostly take tasks from
+ * themselves or each other. We cannot negate this in the
+ * implementation of other management responsibilities. The main
+ * tactic for avoiding bottlenecks is packing nearly all
+ * essentially atomic control state into a single 64bit volatile
+ * variable ("ctl"). This variable is read on the order of 10-100
+ * times as often as it is modified (always via CAS). (There is
+ * some additional control state, for example variable "shutdown"
+ * for which we can cope with uncoordinated updates.) This
+ * streamlines synchronization and control at the expense of messy
+ * constructions needed to repack status bits upon updates.
+ * Updates tend not to contend with each other except during
+ * bursts while submitted tasks begin or end. In some cases when
+ * they do contend, threads can instead do something else
+ * (usually, scan for tasks) until contention subsides.
+ *
+ * To enable packing, we restrict maximum parallelism to (1<<15)-1
+ * (which is far in excess of normal operating range) to allow
+ * ids, counts, and their negations (used for thresholding) to fit
+ * into 16bit fields.
+ *
+ * Recording Workers. Workers are recorded in the "workers" array
+ * that is created upon pool construction and expanded if (rarely)
+ * necessary. This is an array as opposed to some other data
+ * structure to support index-based random steals by workers.
+ * Updates to the array recording new workers and unrecording
+ * terminated ones are protected from each other by a seqLock
+ * (scanGuard) but the array is otherwise concurrently readable,
+ * and accessed directly by workers. To simplify index-based
+ * operations, the array size is always a power of two, and all
+ * readers must tolerate null slots. To avoid flailing during
+ * start-up, the array is presized to hold twice #parallelism
+ * workers (which is unlikely to need further resizing during
+ * execution). But to avoid dealing with so many null slots,
+ * variable scanGuard includes a mask for the nearest power of two
+ * that contains all current workers. All worker thread creation
+ * is on-demand, triggered by task submissions, replacement of
+ * terminated workers, and/or compensation for blocked
+ * workers. However, all other support code is set up to work with
+ * other policies. To ensure that we do not hold on to worker
+ * references that would prevent GC, ALL accesses to workers are
+ * via indices into the workers array (which is one source of some
+ * of the messy code constructions here). In essence, the workers
+ * array serves as a weak reference mechanism. Thus for example
+ * the wait queue field of ctl stores worker indices, not worker
+ * references. Access to the workers in associated methods (for
+ * example signalWork) must both index-check and null-check the
+ * IDs. All such accesses ignore bad IDs by returning out early
+ * from what they are doing, since this can only be associated
+ * with termination, in which case it is OK to give up.
*
- * Beyond work-stealing support and essential bookkeeping, the
- * main responsibility of this framework is to take actions when
- * one worker is waiting to join a task stolen (or always held by)
- * another. Because we are multiplexing many tasks on to a pool
- * of workers, we can't just let them block (as in Thread.join).
- * We also cannot just reassign the joiner's run-time stack with
- * another and replace it later, which would be a form of
- * "continuation", that even if possible is not necessarily a good
- * idea. Given that the creation costs of most threads on most
- * systems mainly surrounds setting up runtime stacks, thread
- * creation and switching is usually not much more expensive than
- * stack creation and switching, and is more flexible). Instead we
+ * All uses of the workers array, as well as queue arrays, check
+ * that the array is non-null (even if previously non-null). This
+ * allows nulling during termination, which is currently not
+ * necessary, but remains an option for resource-revocation-based
+ * shutdown schemes.
+ *
+ * Wait Queuing. Unlike HPC work-stealing frameworks, we cannot
+ * let workers spin indefinitely scanning for tasks when none can
+ * be found immediately, and we cannot start/resume workers unless
+ * there appear to be tasks available. On the other hand, we must
+ * quickly prod them into action when new tasks are submitted or
+ * generated. We park/unpark workers after placing in an event
+ * wait queue when they cannot find work. This "queue" is actually
+ * a simple Treiber stack, headed by the "id" field of ctl, plus a
+ * 15bit counter value to both wake up waiters (by advancing their
+ * count) and avoid ABA effects. Successors are held in worker
+ * field "nextWait". Queuing deals with several intrinsic races,
+ * mainly that a task-producing thread can miss seeing (and
+ * signalling) another thread that gave up looking for work but
+ * has not yet entered the wait queue. We solve this by requiring
+ * a full sweep of all workers both before (in scan()) and after
+ * (in tryAwaitWork()) a newly waiting worker is added to the wait
+ * queue. During a rescan, the worker might release some other
+ * queued worker rather than itself, which has the same net
+ * effect. Because enqueued workers may actually be rescanning
+ * rather than waiting, we set and clear the "parked" field of
+ * ForkJoinWorkerThread to reduce unnecessary calls to unpark.
+ * (Use of the parked field requires a secondary recheck to avoid
+ * missed signals.)
+ *
+ * Signalling. We create or wake up workers only when there
+ * appears to be at least one task they might be able to find and
+ * execute. When a submission is added or another worker adds a
+ * task to a queue that previously had two or fewer tasks, they
+ * signal waiting workers (or trigger creation of new ones if
+ * fewer than the given parallelism level -- see signalWork).
+ * These primary signals are buttressed by signals during rescans
+ * as well as those performed when a worker steals a task and
+ * notices that there are more tasks too; together these cover the
+ * signals needed in cases when more than two tasks are pushed
+ * but untaken.
+ *
+ * Trimming workers. To release resources after periods of lack of
+ * use, a worker starting to wait when the pool is quiescent will
+ * time out and terminate if the pool has remained quiescent for
+ * SHRINK_RATE nanosecs. This will slowly propagate, eventually
+ * terminating all workers after long periods of non-use.
+ *
+ * Submissions. External submissions are maintained in an
+ * array-based queue that is structured identically to
+ * ForkJoinWorkerThread queues except for the use of
+ * submissionLock in method addSubmission. Unlike the case for
+ * worker queues, multiple external threads can add new
+ * submissions, so adding requires a lock.
+ *
+ * Compensation. Beyond work-stealing support and lifecycle
+ * control, the main responsibility of this framework is to take
+ * actions when one worker is waiting to join a task stolen (or
+ * always held by) another. Because we are multiplexing many
+ * tasks on to a pool of workers, we can't just let them block (as
+ * in Thread.join). We also cannot just reassign the joiner's
+ * run-time stack with another and replace it later, which would
+ * be a form of "continuation", that even if possible is not
+ * necessarily a good idea since we sometimes need both an
+ * unblocked task and its continuation to progress. Instead we
* combine two tactics:
*
* Helping: Arranging for the joiner to execute some task that it
* would be running if the steal had not occurred. Method
- * ForkJoinWorkerThread.helpJoinTask tracks joining->stealing
+ * ForkJoinWorkerThread.joinTask tracks joining->stealing
* links to try to find such a task.
*
* Compensating: Unless there are already enough live threads,
- * method helpMaintainParallelism() may create or
- * re-activate a spare thread to compensate for blocked
- * joiners until they unblock.
- *
- * It is impossible to keep exactly the target (parallelism)
- * number of threads running at any given time. Determining
- * existence of conservatively safe helping targets, the
- * availability of already-created spares, and the apparent need
- * to create new spares are all racy and require heuristic
- * guidance, so we rely on multiple retries of each. Compensation
- * occurs in slow-motion. It is triggered only upon timeouts of
- * Object.wait used for joins. This reduces poor decisions that
- * would otherwise be made when threads are waiting for others
- * that are stalled because of unrelated activities such as
- * garbage collection.
+ * method tryPreBlock() may create or re-activate a spare
+ * thread to compensate for blocked joiners until they
+ * unblock.
*
* The ManagedBlocker extension API can't use helping so relies
* only on compensation in method awaitBlocker.
*
- * The main throughput advantages of work-stealing stem from
- * decentralized control -- workers mostly steal tasks from each
- * other. We do not want to negate this by creating bottlenecks
- * implementing other management responsibilities. So we use a
- * collection of techniques that avoid, reduce, or cope well with
- * contention. These entail several instances of bit-packing into
- * CASable fields to maintain only the minimally required
- * atomicity. To enable such packing, we restrict maximum
- * parallelism to (1<<15)-1 (enabling twice this (to accommodate
- * unbalanced increments and decrements) to fit into a 16 bit
- * field, which is far in excess of normal operating range. Even
- * though updates to some of these bookkeeping fields do sometimes
- * contend with each other, they don't normally cache-contend with
- * updates to others enough to warrant memory padding or
- * isolation. So they are all held as fields of ForkJoinPool
- * objects. The main capabilities are as follows:
- *
- * 1. Creating and removing workers. Workers are recorded in the
- * "workers" array. This is an array as opposed to some other data
- * structure to support index-based random steals by workers.
- * Updates to the array recording new workers and unrecording
- * terminated ones are protected from each other by a lock
- * (workerLock) but the array is otherwise concurrently readable,
- * and accessed directly by workers. To simplify index-based
- * operations, the array size is always a power of two, and all
- * readers must tolerate null slots. Currently, all worker thread
- * creation is on-demand, triggered by task submissions,
- * replacement of terminated workers, and/or compensation for
- * blocked workers. However, all other support code is set up to
- * work with other policies.
- *
- * To ensure that we do not hold on to worker references that
- * would prevent GC, ALL accesses to workers are via indices into
- * the workers array (which is one source of some of the unusual
- * code constructions here). In essence, the workers array serves
- * as a WeakReference mechanism. Thus for example the event queue
- * stores worker indices, not worker references. Access to the
- * workers in associated methods (for example releaseEventWaiters)
- * must both index-check and null-check the IDs. All such accesses
- * ignore bad IDs by returning out early from what they are doing,
- * since this can only be associated with shutdown, in which case
- * it is OK to give up. On termination, we just clobber these
- * data structures without trying to use them.
- *
- * 2. Bookkeeping for dynamically adding and removing workers. We
- * aim to approximately maintain the given level of parallelism.
- * When some workers are known to be blocked (on joins or via
- * ManagedBlocker), we may create or resume others to take their
- * place until they unblock (see below). Implementing this
- * requires counts of the number of "running" threads (i.e., those
- * that are neither blocked nor artificially suspended) as well as
- * the total number. These two values are packed into one field,
- * "workerCounts" because we need accurate snapshots when deciding
- * to create, resume or suspend. Note however that the
- * correspondence of these counts to reality is not guaranteed. In
- * particular updates for unblocked threads may lag until they
- * actually wake up.
- *
- * 3. Maintaining global run state. The run state of the pool
- * consists of a runLevel (SHUTDOWN, TERMINATING, etc) similar to
- * those in other Executor implementations, as well as a count of
- * "active" workers -- those that are, or soon will be, or
- * recently were executing tasks. The runLevel and active count
- * are packed together in order to correctly trigger shutdown and
- * termination. Without care, active counts can be subject to very
- * high contention. We substantially reduce this contention by
- * relaxing update rules. A worker must claim active status
- * prospectively, by activating if it sees that a submitted or
- * stealable task exists (it may find after activating that the
- * task no longer exists). It stays active while processing this
- * task (if it exists) and any other local subtasks it produces,
- * until it cannot find any other tasks. It then tries
- * inactivating (see method preStep), but upon update contention
- * instead scans for more tasks, later retrying inactivation if it
- * doesn't find any.
+ * It is impossible to keep exactly the target parallelism number
+ * of threads running at any given time. Determining the
+ * existence of conservatively safe helping targets, the
+ * availability of already-created spares, and the apparent need
+ * to create new spares are all racy and require heuristic
+ * guidance, so we rely on multiple retries of each. Currently,
+ * in keeping with on-demand signalling policy, we compensate only
+ * if blocking would leave less than one active (non-waiting,
+ * non-blocked) worker. Additionally, to avoid some false alarms
+ * due to GC, lagging counters, system activity, etc, compensated
+ * blocking for joins is only attempted after rechecks stabilize
+ * (retries are interspersed with Thread.yield, for good
+ * citizenship). The variable blockedCount, incremented before
+ * blocking and decremented after, is sometimes needed to
+ * distinguish cases of waiting for work vs blocking on joins or
+ * other managed sync. Both cases are equivalent for most pool
+ * control, so we can update non-atomically. (Additionally,
+ * contention on blockedCount alleviates some contention on ctl).
*
- * 4. Managing idle workers waiting for tasks. We cannot let
- * workers spin indefinitely scanning for tasks when none are
- * available. On the other hand, we must quickly prod them into
- * action when new tasks are submitted or generated. We
- * park/unpark these idle workers using an event-count scheme.
- * Field eventCount is incremented upon events that may enable
- * workers that previously could not find a task to now find one:
- * Submission of a new task to the pool, or another worker pushing
- * a task onto a previously empty queue. (We also use this
- * mechanism for configuration and termination actions that
- * require wakeups of idle workers). Each worker maintains its
- * last known event count, and blocks when a scan for work did not
- * find a task AND its lastEventCount matches the current
- * eventCount. Waiting idle workers are recorded in a variant of
- * Treiber stack headed by field eventWaiters which, when nonzero,
- * encodes the thread index and count awaited for by the worker
- * thread most recently calling eventSync. This thread in turn has
- * a record (field nextEventWaiter) for the next waiting worker.
- * In addition to allowing simpler decisions about need for
- * wakeup, the event count bits in eventWaiters serve the role of
- * tags to avoid ABA errors in Treiber stacks. Upon any wakeup,
- * released threads also try to release at most two others. The
- * net effect is a tree-like diffusion of signals, where released
- * threads (and possibly others) help with unparks. To further
- * reduce contention effects a bit, failed CASes to increment
- * field eventCount are tolerated without retries in signalWork.
- * Conceptually they are merged into the same event, which is OK
- * when their only purpose is to enable workers to scan for work.
+ * Shutdown and Termination. A call to shutdownNow atomically sets
+ * the ctl stop bit and then (non-atomically) sets each workers
+ * "terminate" status, cancels all unprocessed tasks, and wakes up
+ * all waiting workers. Detecting whether termination should
+ * commence after a non-abrupt shutdown() call requires more work
+ * and bookkeeping. We need consensus about quiesence (i.e., that
+ * there is no more work) which is reflected in active counts so
+ * long as there are no current blockers, as well as possible
+ * re-evaluations during independent changes in blocking or
+ * quiescing workers.
*
- * 5. Managing suspension of extra workers. When a worker notices
- * (usually upon timeout of a wait()) that there are too few
- * running threads, we may create a new thread to maintain
- * parallelism level, or at least avoid starvation. Usually, extra
- * threads are needed for only very short periods, yet join
- * dependencies are such that we sometimes need them in
- * bursts. Rather than create new threads each time this happens,
- * we suspend no-longer-needed extra ones as "spares". For most
- * purposes, we don't distinguish "extra" spare threads from
- * normal "core" threads: On each call to preStep (the only point
- * at which we can do this) a worker checks to see if there are
- * now too many running workers, and if so, suspends itself.
- * Method helpMaintainParallelism looks for suspended threads to
- * resume before considering creating a new replacement. The
- * spares themselves are encoded on another variant of a Treiber
- * Stack, headed at field "spareWaiters". Note that the use of
- * spares is intrinsically racy. One thread may become a spare at
- * about the same time as another is needlessly being created. We
- * counteract this and related slop in part by requiring resumed
- * spares to immediately recheck (in preStep) to see whether they
- * should re-suspend.
- *
- * 6. Killing off unneeded workers. A timeout mechanism is used to
- * shed unused workers: The oldest (first) event queue waiter uses
- * a timed rather than hard wait. When this wait times out without
- * a normal wakeup, it tries to shutdown any one (for convenience
- * the newest) other spare or event waiter via
- * tryShutdownUnusedWorker. This eventually reduces the number of
- * worker threads to a minimum of one after a long enough period
- * without use.
- *
- * 7. Deciding when to create new workers. The main dynamic
- * control in this class is deciding when to create extra threads
- * in method helpMaintainParallelism. We would like to keep
- * exactly #parallelism threads running, which is an impossible
- * task. We always need to create one when the number of running
- * threads would become zero and all workers are busy. Beyond
- * this, we must rely on heuristics that work well in the
- * presence of transient phenomena such as GC stalls, dynamic
- * compilation, and wake-up lags. These transients are extremely
- * common -- we are normally trying to fully saturate the CPUs on
- * a machine, so almost any activity other than running tasks
- * impedes accuracy. Our main defense is to allow parallelism to
- * lapse for a while during joins, and use a timeout to see if,
- * after the resulting settling, there is still a need for
- * additional workers. This also better copes with the fact that
- * some of the methods in this class tend to never become compiled
- * (but are interpreted), so some components of the entire set of
- * controls might execute 100 times faster than others. And
- * similarly for cases where the apparent lack of work is just due
- * to GC stalls and other transient system activity.
- *
- * Beware that there is a lot of representation-level coupling
+ * Style notes: There is a lot of representation-level coupling
* among classes ForkJoinPool, ForkJoinWorkerThread, and
- * ForkJoinTask. For example, direct access to "workers" array by
+ * ForkJoinTask. Most fields of ForkJoinWorkerThread maintain
+ * data structures managed by ForkJoinPool, so are directly
+ * accessed. Conversely we allow access to "workers" array by
* workers, and direct access to ForkJoinTask.status by both
* ForkJoinPool and ForkJoinWorkerThread. There is little point
* trying to reduce this, since any associated future changes in
* representations will need to be accompanied by algorithmic
- * changes anyway.
+ * changes anyway. All together, these low-level implementation
+ * choices produce as much as a factor of 4 performance
+ * improvement compared to naive implementations, and enable the
+ * processing of billions of tasks per second, at the expense of
+ * some ugliness.
*
- * Style notes: There are lots of inline assignments (of form
- * "while ((local = field) != 0)") which are usually the simplest
- * way to ensure the required read orderings (which are sometimes
- * critical). Also several occurrences of the unusual "do {}
- * while (!cas...)" which is the simplest way to force an update of
- * a CAS'ed variable. There are also other coding oddities that
- * help some methods perform reasonably even when interpreted (not
- * compiled), at the expense of some messy constructions that
- * reduce byte code counts.
+ * Methods signalWork() and scan() are the main bottlenecks so are
+ * especially heavily micro-optimized/mangled. There are lots of
+ * inline assignments (of form "while ((local = field) != 0)")
+ * which are usually the simplest way to ensure the required read
+ * orderings (which are sometimes critical). This leads to a
+ * "C"-like style of listing declarations of these locals at the
+ * heads of methods or blocks. There are several occurrences of
+ * the unusual "do {} while (!cas...)" which is the simplest way
+ * to force an update of a CAS'ed variable. There are also other
+ * coding oddities that help some methods perform reasonably even
+ * when interpreted (not compiled).
*
- * The order of declarations in this file is: (1) statics (2)
- * fields (along with constants used when unpacking some of them)
- * (3) internal control methods (4) callbacks and other support
- * for ForkJoinTask and ForkJoinWorkerThread classes, (5) exported
- * methods (plus a few little helpers).
+ * The order of declarations in this file is: (1) declarations of
+ * statics (2) fields (along with constants used when unpacking
+ * some of them), listed in an order that tends to reduce
+ * contention among them a bit under most JVMs. (3) internal
+ * control methods (4) callbacks and other support for
+ * ForkJoinTask and ForkJoinWorkerThread classes, (5) exported
+ * methods (plus a few little helpers). (6) static block
+ * initializing all statics in a minimally dependent order.
*/
/**
@@ -425,15 +396,13 @@
* overridden in ForkJoinPool constructors.
*/
public static final ForkJoinWorkerThreadFactory
- defaultForkJoinWorkerThreadFactory =
- new DefaultForkJoinWorkerThreadFactory();
+ defaultForkJoinWorkerThreadFactory;
/**
* Permission required for callers of methods that may start or
* kill threads.
*/
- private static final RuntimePermission modifyThreadPermission =
- new RuntimePermission("modifyThread");
+ private static final RuntimePermission modifyThreadPermission;
/**
* If there is a security manager, makes sure caller has
@@ -448,63 +417,59 @@
/**
* Generator for assigning sequence numbers as pool names.
*/
- private static final AtomicInteger poolNumberGenerator =
- new AtomicInteger();
+ private static final AtomicInteger poolNumberGenerator;
/**
- * The time to block in a join (see awaitJoin) before checking if
- * a new worker should be (re)started to maintain parallelism
- * level. The value should be short enough to maintain global
- * responsiveness and progress but long enough to avoid
- * counterproductive firings during GC stalls or unrelated system
- * activity, and to not bog down systems with continual re-firings
- * on GCs or legitimately long waits.
+ * Generator for initial random seeds for worker victim
+ * selection. This is used only to create initial seeds. Random
+ * steals use a cheaper xorshift generator per steal attempt. We
+ * don't expect much contention on seedGenerator, so just use a
+ * plain Random.
*/
- private static final long JOIN_TIMEOUT_MILLIS = 250L; // 4 per second
+ static final Random workerSeedGenerator;
/**
- * The wakeup interval (in nanoseconds) for the oldest worker
- * waiting for an event to invoke tryShutdownUnusedWorker to
- * shrink the number of workers. The exact value does not matter
- * too much. It must be short enough to release resources during
- * sustained periods of idleness, but not so short that threads
- * are continually re-created.
+ * Array holding all worker threads in the pool. Initialized upon
+ * construction. Array size must be a power of two. Updates and
+ * replacements are protected by scanGuard, but the array is
+ * always kept in a consistent enough state to be randomly
+ * accessed without locking by workers performing work-stealing,
+ * as well as other traversal-based methods in this class, so long
+ * as reads memory-acquire by first reading ctl. All readers must
+ * tolerate that some array slots may be null.
*/
- private static final long SHRINK_RATE_NANOS =
- 30L * 1000L * 1000L * 1000L; // 2 per minute
+ ForkJoinWorkerThread[] workers;
/**
- * Absolute bound for parallelism level. Twice this number plus
- * one (i.e., 0xfff) must fit into a 16bit field to enable
- * word-packing for some counts and indices.
+ * Initial size for submission queue array. Must be a power of
+ * two. In many applications, these always stay small so we use a
+ * small initial cap.
*/
- private static final int MAX_WORKERS = 0x7fff;
+ private static final int INITIAL_QUEUE_CAPACITY = 8;
+
+ /**
+ * Maximum size for submission queue array. Must be a power of two
+ * less than or equal to 1 << (31 - width of array entry) to
+ * ensure lack of index wraparound, but is capped at a lower
+ * value to help users trap runaway computations.
+ */
+ private static final int MAXIMUM_QUEUE_CAPACITY = 1 << 24; // 16M
/**
- * Array holding all worker threads in the pool. Array size must
- * be a power of two. Updates and replacements are protected by
- * workerLock, but the array is always kept in a consistent enough
- * state to be randomly accessed without locking by workers
- * performing work-stealing, as well as other traversal-based
- * methods in this class. All readers must tolerate that some
- * array slots may be null.
+ * Array serving as submission queue. Initialized upon construction.
*/
- volatile ForkJoinWorkerThread[] workers;
+ private ForkJoinTask<?>[] submissionQueue;
/**
- * Queue for external submissions.
+ * Lock protecting submissions array for addSubmission
*/
- private final LinkedTransferQueue<ForkJoinTask<?>> submissionQueue;
+ private final ReentrantLock submissionLock;
/**
- * Lock protecting updates to workers array.
+ * Condition for awaitTermination, using submissionLock for
+ * convenience.
*/
- private final ReentrantLock workerLock;
-
- /**
- * Latch released upon termination.
- */
- private final Phaser termination;
+ private final Condition termination;
/**
* Creation factory for worker threads.
@@ -512,227 +477,719 @@
private final ForkJoinWorkerThreadFactory factory;
/**
+ * The uncaught exception handler used when any worker abruptly
+ * terminates.
+ */
+ final Thread.UncaughtExceptionHandler ueh;
+
+ /**
+ * Prefix for assigning names to worker threads
+ */
+ private final String workerNamePrefix;
+
+ /**
* Sum of per-thread steal counts, updated only when threads are
* idle or terminating.
*/
private volatile long stealCount;
/**
- * Encoded record of top of Treiber stack of threads waiting for
- * events. The top 32 bits contain the count being waited for. The
- * bottom 16 bits contains one plus the pool index of waiting
- * worker thread. (Bits 16-31 are unused.)
+ * Main pool control -- a long packed with:
+ * AC: Number of active running workers minus target parallelism (16 bits)
+ * TC: Number of total workers minus target parallelism (16bits)
+ * ST: true if pool is terminating (1 bit)
+ * EC: the wait count of top waiting thread (15 bits)
+ * ID: ~poolIndex of top of Treiber stack of waiting threads (16 bits)
+ *
+ * When convenient, we can extract the upper 32 bits of counts and
+ * the lower 32 bits of queue state, u = (int)(ctl >>> 32) and e =
+ * (int)ctl. The ec field is never accessed alone, but always
+ * together with id and st. The offsets of counts by the target
+ * parallelism and the positionings of fields makes it possible to
+ * perform the most common checks via sign tests of fields: When
+ * ac is negative, there are not enough active workers, when tc is
+ * negative, there are not enough total workers, when id is
+ * negative, there is at least one waiting worker, and when e is
+ * negative, the pool is terminating. To deal with these possibly
+ * negative fields, we use casts in and out of "short" and/or
+ * signed shifts to maintain signedness.
*/
- private volatile long eventWaiters;
-
- private static final int EVENT_COUNT_SHIFT = 32;
- private static final int WAITER_ID_MASK = (1 << 16) - 1;
-
- /**
- * A counter for events that may wake up worker threads:
- * - Submission of a new task to the pool
- * - A worker pushing a task on an empty queue
- * - termination
- */
- private volatile int eventCount;
-
- /**
- * Encoded record of top of Treiber stack of spare threads waiting
- * for resumption. The top 16 bits contain an arbitrary count to
- * avoid ABA effects. The bottom 16bits contains one plus the pool
- * index of waiting worker thread.
- */
- private volatile int spareWaiters;
-
- private static final int SPARE_COUNT_SHIFT = 16;
- private static final int SPARE_ID_MASK = (1 << 16) - 1;
+ volatile long ctl;
- /**
- * Lifecycle control. The low word contains the number of workers
- * that are (probably) executing tasks. This value is atomically
- * incremented before a worker gets a task to run, and decremented
- * when a worker has no tasks and cannot find any. Bits 16-18
- * contain runLevel value. When all are zero, the pool is
- * running. Level transitions are monotonic (running -> shutdown
- * -> terminating -> terminated) so each transition adds a bit.
- * These are bundled together to ensure consistent read for
- * termination checks (i.e., that runLevel is at least SHUTDOWN
- * and active threads is zero).
- *
- * Notes: Most direct CASes are dependent on these bitfield
- * positions. Also, this field is non-private to enable direct
- * performance-sensitive CASes in ForkJoinWorkerThread.
- */
- volatile int runState;
+ // bit positions/shifts for fields
+ private static final int AC_SHIFT = 48;
+ private static final int TC_SHIFT = 32;
+ private static final int ST_SHIFT = 31;
+ private static final int EC_SHIFT = 16;
+
+ // bounds
+ private static final int MAX_ID = 0x7fff; // max poolIndex
+ private static final int SMASK = 0xffff; // mask short bits
+ private static final int SHORT_SIGN = 1 << 15;
+ private static final int INT_SIGN = 1 << 31;
- // Note: The order among run level values matters.
- private static final int RUNLEVEL_SHIFT = 16;
- private static final int SHUTDOWN = 1 << RUNLEVEL_SHIFT;
- private static final int TERMINATING = 1 << (RUNLEVEL_SHIFT + 1);
- private static final int TERMINATED = 1 << (RUNLEVEL_SHIFT + 2);
- private static final int ACTIVE_COUNT_MASK = (1 << RUNLEVEL_SHIFT) - 1;
+ // masks
+ private static final long STOP_BIT = 0x0001L << ST_SHIFT;
+ private static final long AC_MASK = ((long)SMASK) << AC_SHIFT;
+ private static final long TC_MASK = ((long)SMASK) << TC_SHIFT;
+
+ // units for incrementing and decrementing
+ private static final long TC_UNIT = 1L << TC_SHIFT;
+ private static final long AC_UNIT = 1L << AC_SHIFT;
- /**
- * Holds number of total (i.e., created and not yet terminated)
- * and running (i.e., not blocked on joins or other managed sync)
- * threads, packed together to ensure consistent snapshot when
- * making decisions about creating and suspending spare
- * threads. Updated only by CAS. Note that adding a new worker
- * requires incrementing both counts, since workers start off in
- * running state.
- */
- private volatile int workerCounts;
+ // masks and units for dealing with u = (int)(ctl >>> 32)
+ private static final int UAC_SHIFT = AC_SHIFT - 32;
+ private static final int UTC_SHIFT = TC_SHIFT - 32;
+ private static final int UAC_MASK = SMASK << UAC_SHIFT;
+ private static final int UTC_MASK = SMASK << UTC_SHIFT;
+ private static final int UAC_UNIT = 1 << UAC_SHIFT;
+ private static final int UTC_UNIT = 1 << UTC_SHIFT;
- private static final int TOTAL_COUNT_SHIFT = 16;
- private static final int RUNNING_COUNT_MASK = (1 << TOTAL_COUNT_SHIFT) - 1;
- private static final int ONE_RUNNING = 1;
- private static final int ONE_TOTAL = 1 << TOTAL_COUNT_SHIFT;
+ // masks and units for dealing with e = (int)ctl
+ private static final int E_MASK = 0x7fffffff; // no STOP_BIT
+ private static final int EC_UNIT = 1 << EC_SHIFT;
/**
* The target parallelism level.
- * Accessed directly by ForkJoinWorkerThreads.
*/
final int parallelism;
/**
+ * Index (mod submission queue length) of next element to take
+ * from submission queue. Usage is identical to that for
+ * per-worker queues -- see ForkJoinWorkerThread internal
+ * documentation.
+ */
+ volatile int queueBase;
+
+ /**
+ * Index (mod submission queue length) of next element to add
+ * in submission queue. Usage is identical to that for
+ * per-worker queues -- see ForkJoinWorkerThread internal
+ * documentation.
+ */
+ int queueTop;
+
+ /**
+ * True when shutdown() has been called.
+ */
+ volatile boolean shutdown;
+
+ /**
* True if use local fifo, not default lifo, for local polling
* Read by, and replicated by ForkJoinWorkerThreads
*/
final boolean locallyFifo;
/**
- * The uncaught exception handler used when any worker abruptly
- * terminates.
+ * The number of threads in ForkJoinWorkerThreads.helpQuiescePool.
+ * When non-zero, suppresses automatic shutdown when active
+ * counts become zero.
+ */
+ volatile int quiescerCount;
+
+ /**
+ * The number of threads blocked in join.
+ */
+ volatile int blockedCount;
+
+ /**
+ * Counter for worker Thread names (unrelated to their poolIndex)
+ */
+ private volatile int nextWorkerNumber;
+
+ /**
+ * The index for the next created worker. Accessed under scanGuard.
*/
- private final Thread.UncaughtExceptionHandler ueh;
+ private int nextWorkerIndex;
+
+ /**
+ * SeqLock and index masking for updates to workers array. Locked
+ * when SG_UNIT is set. Unlocking clears bit by adding
+ * SG_UNIT. Staleness of read-only operations can be checked by
+ * comparing scanGuard to value before the reads. The low 16 bits
+ * (i.e, anding with SMASK) hold (the smallest power of two
+ * covering all worker indices, minus one, and is used to avoid
+ * dealing with large numbers of null slots when the workers array
+ * is overallocated.
+ */
+ volatile int scanGuard;
+
+ private static final int SG_UNIT = 1 << 16;
+
+ /**
+ * The wakeup interval (in nanoseconds) for a worker waiting for a
+ * task when the pool is quiescent to instead try to shrink the
+ * number of workers. The exact value does not matter too
+ * much. It must be short enough to release resources during
+ * sustained periods of idleness, but not so short that threads
+ * are continually re-created.
+ */
+ private static final long SHRINK_RATE =
+ 4L * 1000L * 1000L * 1000L; // 4 seconds
/**
- * Pool number, just for assigning useful names to worker threads
+ * Top-level loop for worker threads: On each step: if the
+ * previous step swept through all queues and found no tasks, or
+ * there are excess threads, then possibly blocks. Otherwise,
+ * scans for and, if found, executes a task. Returns when pool
+ * and/or worker terminate.
+ *
+ * @param w the worker
*/
- private final int poolNumber;
+ final void work(ForkJoinWorkerThread w) {
+ boolean swept = false; // true on empty scans
+ long c;
+ while (!w.terminate && (int)(c = ctl) >= 0) {
+ int a; // active count
+ if (!swept && (a = (int)(c >> AC_SHIFT)) <= 0)
+ swept = scan(w, a);
+ else if (tryAwaitWork(w, c))
+ swept = false;
+ }
+ }
- // Utilities for CASing fields. Note that most of these
- // are usually manually inlined by callers
+ // Signalling
/**
- * Increments running count part of workerCounts.
+ * Wakes up or creates a worker.
*/
- final void incrementRunningCount() {
- int c;
- do {} while (!UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- c = workerCounts,
- c + ONE_RUNNING));
+ final void signalWork() {
+ /*
+ * The while condition is true if: (there is are too few total
+ * workers OR there is at least one waiter) AND (there are too
+ * few active workers OR the pool is terminating). The value
+ * of e distinguishes the remaining cases: zero (no waiters)
+ * for create, negative if terminating (in which case do
+ * nothing), else release a waiter. The secondary checks for
+ * release (non-null array etc) can fail if the pool begins
+ * terminating after the test, and don't impose any added cost
+ * because JVMs must perform null and bounds checks anyway.
+ */
+ long c; int e, u;
+ while ((((e = (int)(c = ctl)) | (u = (int)(c >>> 32))) &
+ (INT_SIGN|SHORT_SIGN)) == (INT_SIGN|SHORT_SIGN) && e >= 0) {
+ if (e > 0) { // release a waiting worker
+ int i; ForkJoinWorkerThread w; ForkJoinWorkerThread[] ws;
+ if ((ws = workers) == null ||
+ (i = ~e & SMASK) >= ws.length ||
+ (w = ws[i]) == null)
+ break;
+ long nc = (((long)(w.nextWait & E_MASK)) |
+ ((long)(u + UAC_UNIT) << 32));
+ if (w.eventCount == e &&
+ UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc)) {
+ w.eventCount = (e + EC_UNIT) & E_MASK;
+ if (w.parked)
+ UNSAFE.unpark(w);
+ break;
+ }
+ }
+ else if (UNSAFE.compareAndSwapLong
+ (this, ctlOffset, c,
+ (long)(((u + UTC_UNIT) & UTC_MASK) |
+ ((u + UAC_UNIT) & UAC_MASK)) << 32)) {
+ addWorker();
+ break;
+ }
+ }
}
/**
- * Tries to increment running count part of workerCounts.
+ * Variant of signalWork to help release waiters on rescans.
+ * Tries once to release a waiter if active count < 0.
+ *
+ * @return false if failed due to contention, else true
+ */
+ private boolean tryReleaseWaiter() {
+ long c; int e, i; ForkJoinWorkerThread w; ForkJoinWorkerThread[] ws;
+ if ((e = (int)(c = ctl)) > 0 &&
+ (int)(c >> AC_SHIFT) < 0 &&
+ (ws = workers) != null &&
+ (i = ~e & SMASK) < ws.length &&
+ (w = ws[i]) != null) {
+ long nc = ((long)(w.nextWait & E_MASK) |
+ ((c + AC_UNIT) & (AC_MASK|TC_MASK)));
+ if (w.eventCount != e ||
+ !UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc))
+ return false;
+ w.eventCount = (e + EC_UNIT) & E_MASK;
+ if (w.parked)
+ UNSAFE.unpark(w);
+ }
+ return true;
+ }
+
+ // Scanning for tasks
+
+ /**
+ * Scans for and, if found, executes one task. Scans start at a
+ * random index of workers array, and randomly select the first
+ * (2*#workers)-1 probes, and then, if all empty, resort to 2
+ * circular sweeps, which is necessary to check quiescence. and
+ * taking a submission only if no stealable tasks were found. The
+ * steal code inside the loop is a specialized form of
+ * ForkJoinWorkerThread.deqTask, followed bookkeeping to support
+ * helpJoinTask and signal propagation. The code for submission
+ * queues is almost identical. On each steal, the worker completes
+ * not only the task, but also all local tasks that this task may
+ * have generated. On detecting staleness or contention when
+ * trying to take a task, this method returns without finishing
+ * sweep, which allows global state rechecks before retry.
+ *
+ * @param w the worker
+ * @param a the number of active workers
+ * @return true if swept all queues without finding a task
*/
- final boolean tryIncrementRunningCount() {
- int c;
- return UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- c = workerCounts,
- c + ONE_RUNNING);
+ private boolean scan(ForkJoinWorkerThread w, int a) {
+ int g = scanGuard; // mask 0 avoids useless scans if only one active
+ int m = (parallelism == 1 - a && blockedCount == 0) ? 0 : g & SMASK;
+ ForkJoinWorkerThread[] ws = workers;
+ if (ws == null || ws.length <= m) // staleness check
+ return false;
+ for (int r = w.seed, k = r, j = -(m + m); j <= m + m; ++j) {
+ ForkJoinTask<?> t; ForkJoinTask<?>[] q; int b, i;
+ ForkJoinWorkerThread v = ws[k & m];
+ if (v != null && (b = v.queueBase) != v.queueTop &&
+ (q = v.queue) != null && (i = (q.length - 1) & b) >= 0) {
+ long u = (i << ASHIFT) + ABASE;
+ if ((t = q[i]) != null && v.queueBase == b &&
+ UNSAFE.compareAndSwapObject(q, u, t, null)) {
+ int d = (v.queueBase = b + 1) - v.queueTop;
+ v.stealHint = w.poolIndex;
+ if (d != 0)
+ signalWork(); // propagate if nonempty
+ w.execTask(t);
+ }
+ r ^= r << 13; r ^= r >>> 17; w.seed = r ^ (r << 5);
+ return false; // store next seed
+ }
+ else if (j < 0) { // xorshift
+ r ^= r << 13; r ^= r >>> 17; k = r ^= r << 5;
+ }
+ else
+ ++k;
+ }
+ if (scanGuard != g) // staleness check
+ return false;
+ else { // try to take submission
+ ForkJoinTask<?> t; ForkJoinTask<?>[] q; int b, i;
+ if ((b = queueBase) != queueTop &&
+ (q = submissionQueue) != null &&
+ (i = (q.length - 1) & b) >= 0) {
+ long u = (i << ASHIFT) + ABASE;
+ if ((t = q[i]) != null && queueBase == b &&
+ UNSAFE.compareAndSwapObject(q, u, t, null)) {
+ queueBase = b + 1;
+ w.execTask(t);
+ }
+ return false;
+ }
+ return true; // all queues empty
+ }
}
/**
- * Tries to decrement running count unless already zero.
- */
- final boolean tryDecrementRunningCount() {
- int wc = workerCounts;
- if ((wc & RUNNING_COUNT_MASK) == 0)
- return false;
- return UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc, wc - ONE_RUNNING);
- }
-
- /**
- * Forces decrement of encoded workerCounts, awaiting nonzero if
- * (rarely) necessary when other count updates lag.
+ * Tries to enqueue worker w in wait queue and await change in
+ * worker's eventCount. If the pool is quiescent, possibly
+ * terminates worker upon exit. Otherwise, before blocking,
+ * rescans queues to avoid missed signals. Upon finding work,
+ * releases at least one worker (which may be the current
+ * worker). Rescans restart upon detected staleness or failure to
+ * release due to contention. Note the unusual conventions about
+ * Thread.interrupt here and elsewhere: Because interrupts are
+ * used solely to alert threads to check termination, which is
+ * checked here anyway, we clear status (using Thread.interrupted)
+ * before any call to park, so that park does not immediately
+ * return due to status being set via some other unrelated call to
+ * interrupt in user code.
*
- * @param dr -- either zero or ONE_RUNNING
- * @param dt -- either zero or ONE_TOTAL
+ * @param w the calling worker
+ * @param c the ctl value on entry
+ * @return true if waited or another thread was released upon enq
*/
- private void decrementWorkerCounts(int dr, int dt) {
- for (;;) {
- int wc = workerCounts;
- if ((wc & RUNNING_COUNT_MASK) - dr < 0 ||
- (wc >>> TOTAL_COUNT_SHIFT) - dt < 0) {
- if ((runState & TERMINATED) != 0)
- return; // lagging termination on a backout
- Thread.yield();
+ private boolean tryAwaitWork(ForkJoinWorkerThread w, long c) {
+ int v = w.eventCount;
+ w.nextWait = (int)c; // w's successor record
+ long nc = (long)(v & E_MASK) | ((c - AC_UNIT) & (AC_MASK|TC_MASK));
+ if (ctl != c || !UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc)) {
+ long d = ctl; // return true if lost to a deq, to force scan
+ return (int)d != (int)c && ((d - c) & AC_MASK) >= 0L;
+ }
+ for (int sc = w.stealCount; sc != 0;) { // accumulate stealCount
+ long s = stealCount;
+ if (UNSAFE.compareAndSwapLong(this, stealCountOffset, s, s + sc))
+ sc = w.stealCount = 0;
+ else if (w.eventCount != v)
+ return true; // update next time
+ }
+ if (parallelism + (int)(nc >> AC_SHIFT) == 0 &&
+ blockedCount == 0 && quiescerCount == 0)
+ idleAwaitWork(w, nc, c, v); // quiescent
+ for (boolean rescanned = false;;) {
+ if (w.eventCount != v)
+ return true;
+ if (!rescanned) {
+ int g = scanGuard, m = g & SMASK;
+ ForkJoinWorkerThread[] ws = workers;
+ if (ws != null && m < ws.length) {
+ rescanned = true;
+ for (int i = 0; i <= m; ++i) {
+ ForkJoinWorkerThread u = ws[i];
+ if (u != null) {
+ if (u.queueBase != u.queueTop &&
+ !tryReleaseWaiter())
+ rescanned = false; // contended
+ if (w.eventCount != v)
+ return true;
+ }
+ }
+ }
+ if (scanGuard != g || // stale
+ (queueBase != queueTop && !tryReleaseWaiter()))
+ rescanned = false;
+ if (!rescanned)
+ Thread.yield(); // reduce contention
+ else
+ Thread.interrupted(); // clear before park
}
- if (UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc, wc - (dr + dt)))
- return;
+ else {
+ w.parked = true; // must recheck
+ if (w.eventCount != v) {
+ w.parked = false;
+ return true;
+ }
+ LockSupport.park(this);
+ rescanned = w.parked = false;
+ }
}
}
/**
- * Tries decrementing active count; fails on contention.
- * Called when workers cannot find tasks to run.
+ * If inactivating worker w has caused pool to become
+ * quiescent, check for pool termination, and wait for event
+ * for up to SHRINK_RATE nanosecs (rescans are unnecessary in
+ * this case because quiescence reflects consensus about lack
+ * of work). On timeout, if ctl has not changed, terminate the
+ * worker. Upon its termination (see deregisterWorker), it may
+ * wake up another worker to possibly repeat this process.
+ *
+ * @param w the calling worker
+ * @param currentCtl the ctl value after enqueuing w
+ * @param prevCtl the ctl value if w terminated
+ * @param v the eventCount w awaits change
*/
- final boolean tryDecrementActiveCount() {
- int c;
- return UNSAFE.compareAndSwapInt(this, runStateOffset,
- c = runState, c - 1);
+ private void idleAwaitWork(ForkJoinWorkerThread w, long currentCtl,
+ long prevCtl, int v) {
+ if (w.eventCount == v) {
+ if (shutdown)
+ tryTerminate(false);
+ ForkJoinTask.helpExpungeStaleExceptions(); // help clean weak refs
+ while (ctl == currentCtl) {
+ long startTime = System.nanoTime();
+ w.parked = true;
+ if (w.eventCount == v) // must recheck
+ LockSupport.parkNanos(this, SHRINK_RATE);
+ w.parked = false;
+ if (w.eventCount != v)
+ break;
+ else if (System.nanoTime() - startTime < SHRINK_RATE)
+ Thread.interrupted(); // spurious wakeup
+ else if (UNSAFE.compareAndSwapLong(this, ctlOffset,
+ currentCtl, prevCtl)) {
+ w.terminate = true; // restore previous
+ w.eventCount = ((int)currentCtl + EC_UNIT) & E_MASK;
+ break;
+ }
+ }
+ }
}
+ // Submissions
+
/**
- * Advances to at least the given level. Returns true if not
- * already in at least the given level.
+ * Enqueues the given task in the submissionQueue. Same idea as
+ * ForkJoinWorkerThread.pushTask except for use of submissionLock.
+ *
+ * @param t the task
*/
- private boolean advanceRunLevel(int level) {
- for (;;) {
- int s = runState;
- if ((s & level) != 0)
- return false;
- if (UNSAFE.compareAndSwapInt(this, runStateOffset, s, s | level))
- return true;
+ private void addSubmission(ForkJoinTask<?> t) {
+ final ReentrantLock lock = this.submissionLock;
+ lock.lock();
+ try {
+ ForkJoinTask<?>[] q; int s, m;
+ if ((q = submissionQueue) != null) { // ignore if queue removed
+ long u = (((s = queueTop) & (m = q.length-1)) << ASHIFT)+ABASE;
+ UNSAFE.putOrderedObject(q, u, t);
+ queueTop = s + 1;
+ if (s - queueBase == m)
+ growSubmissionQueue();
+ }
+ } finally {
+ lock.unlock();
+ }
+ signalWork();
+ }
+
+ // (pollSubmission is defined below with exported methods)
+
+ /**
+ * Creates or doubles submissionQueue array.
+ * Basically identical to ForkJoinWorkerThread version.
+ */
+ private void growSubmissionQueue() {
+ ForkJoinTask<?>[] oldQ = submissionQueue;
+ int size = oldQ != null ? oldQ.length << 1 : INITIAL_QUEUE_CAPACITY;
+ if (size > MAXIMUM_QUEUE_CAPACITY)
+ throw new RejectedExecutionException("Queue capacity exceeded");
+ if (size < INITIAL_QUEUE_CAPACITY)
+ size = INITIAL_QUEUE_CAPACITY;
+ ForkJoinTask<?>[] q = submissionQueue = new ForkJoinTask<?>[size];
+ int mask = size - 1;
+ int top = queueTop;
+ int oldMask;
+ if (oldQ != null && (oldMask = oldQ.length - 1) >= 0) {
+ for (int b = queueBase; b != top; ++b) {
+ long u = ((b & oldMask) << ASHIFT) + ABASE;
+ Object x = UNSAFE.getObjectVolatile(oldQ, u);
+ if (x != null && UNSAFE.compareAndSwapObject(oldQ, u, x, null))
+ UNSAFE.putObjectVolatile
+ (q, ((b & mask) << ASHIFT) + ABASE, x);
+ }
}
}
- // workers array maintenance
+ // Blocking support
/**
- * Records and returns a workers array index for new worker.
+ * Tries to increment blockedCount, decrement active count
+ * (sometimes implicitly) and possibly release or create a
+ * compensating worker in preparation for blocking. Fails
+ * on contention or termination.
+ *
+ * @return true if the caller can block, else should recheck and retry
*/
- private int recordWorker(ForkJoinWorkerThread w) {
- // Try using slot totalCount-1. If not available, scan and/or resize
- int k = (workerCounts >>> TOTAL_COUNT_SHIFT) - 1;
- final ReentrantLock lock = this.workerLock;
- lock.lock();
- try {
- ForkJoinWorkerThread[] ws = workers;
- int n = ws.length;
- if (k < 0 || k >= n || ws[k] != null) {
- for (k = 0; k < n && ws[k] != null; ++k)
- ;
- if (k == n)
- ws = workers = Arrays.copyOf(ws, n << 1);
+ private boolean tryPreBlock() {
+ int b = blockedCount;
+ if (UNSAFE.compareAndSwapInt(this, blockedCountOffset, b, b + 1)) {
+ int pc = parallelism;
+ do {
+ ForkJoinWorkerThread[] ws; ForkJoinWorkerThread w;
+ int e, ac, tc, rc, i;
+ long c = ctl;
+ int u = (int)(c >>> 32);
+ if ((e = (int)c) < 0) {
+ // skip -- terminating
+ }
+ else if ((ac = (u >> UAC_SHIFT)) <= 0 && e != 0 &&
+ (ws = workers) != null &&
+ (i = ~e & SMASK) < ws.length &&
+ (w = ws[i]) != null) {
+ long nc = ((long)(w.nextWait & E_MASK) |
+ (c & (AC_MASK|TC_MASK)));
+ if (w.eventCount == e &&
+ UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc)) {
+ w.eventCount = (e + EC_UNIT) & E_MASK;
+ if (w.parked)
+ UNSAFE.unpark(w);
+ return true; // release an idle worker
+ }
+ }
+ else if ((tc = (short)(u >>> UTC_SHIFT)) >= 0 && ac + pc > 1) {
+ long nc = ((c - AC_UNIT) & AC_MASK) | (c & ~AC_MASK);
+ if (UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc))
+ return true; // no compensation needed
+ }
+ else if (tc + pc < MAX_ID) {
+ long nc = ((c + TC_UNIT) & TC_MASK) | (c & ~TC_MASK);
+ if (UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc)) {
+ addWorker();
+ return true; // create a replacement
+ }
+ }
+ // try to back out on any failure and let caller retry
+ } while (!UNSAFE.compareAndSwapInt(this, blockedCountOffset,
+ b = blockedCount, b - 1));
+ }
+ return false;
+ }
+
+ /**
+ * Decrements blockedCount and increments active count
+ */
+ private void postBlock() {
+ long c;
+ do {} while (!UNSAFE.compareAndSwapLong(this, ctlOffset, // no mask
+ c = ctl, c + AC_UNIT));
+ int b;
+ do {} while(!UNSAFE.compareAndSwapInt(this, blockedCountOffset,
+ b = blockedCount, b - 1));
+ }
+
+ /**
+ * Possibly blocks waiting for the given task to complete, or
+ * cancels the task if terminating. Fails to wait if contended.
+ *
+ * @param joinMe the task
+ */
+ final void tryAwaitJoin(ForkJoinTask<?> joinMe) {
+ int s;
+ Thread.interrupted(); // clear interrupts before checking termination
+ if (joinMe.status >= 0) {
+ if (tryPreBlock()) {
+ joinMe.tryAwaitDone(0L);
+ postBlock();
}
- ws[k] = w;
- int c = eventCount; // advance event count to ensure visibility
- UNSAFE.compareAndSwapInt(this, eventCountOffset, c, c+1);
- } finally {
- lock.unlock();
+ else if ((ctl & STOP_BIT) != 0L)
+ joinMe.cancelIgnoringExceptions();
}
- return k;
}
/**
- * Nulls out record of worker in workers array.
+ * Possibly blocks the given worker waiting for joinMe to
+ * complete or timeout
+ *
+ * @param joinMe the task
+ * @param millis the wait time for underlying Object.wait
+ */
+ final void timedAwaitJoin(ForkJoinTask<?> joinMe, long nanos) {
+ while (joinMe.status >= 0) {
+ Thread.interrupted();
+ if ((ctl & STOP_BIT) != 0L) {
+ joinMe.cancelIgnoringExceptions();
+ break;
+ }
+ if (tryPreBlock()) {
+ long last = System.nanoTime();
+ while (joinMe.status >= 0) {
+ long millis = TimeUnit.NANOSECONDS.toMillis(nanos);
+ if (millis <= 0)
+ break;
+ joinMe.tryAwaitDone(millis);
+ if (joinMe.status < 0)
+ break;
+ if ((ctl & STOP_BIT) != 0L) {
+ joinMe.cancelIgnoringExceptions();
+ break;
+ }
+ long now = System.nanoTime();
+ nanos -= now - last;
+ last = now;
+ }
+ postBlock();
+ break;
+ }
+ }
+ }
+
+ /**
+ * If necessary, compensates for blocker, and blocks
+ */
+ private void awaitBlocker(ManagedBlocker blocker)
+ throws InterruptedException {
+ while (!blocker.isReleasable()) {
+ if (tryPreBlock()) {
+ try {
+ do {} while (!blocker.isReleasable() && !blocker.block());
+ } finally {
+ postBlock();
+ }
+ break;
+ }
+ }
+ }
+
+ // Creating, registering and deregistring workers
+
+ /**
+ * Tries to create and start a worker; minimally rolls back counts
+ * on failure.
*/
- private void forgetWorker(ForkJoinWorkerThread w) {
- int idx = w.poolIndex;
- // Locking helps method recordWorker avoid unnecessary expansion
- final ReentrantLock lock = this.workerLock;
- lock.lock();
+ private void addWorker() {
+ Throwable ex = null;
+ ForkJoinWorkerThread t = null;
try {
- ForkJoinWorkerThread[] ws = workers;
- if (idx >= 0 && idx < ws.length && ws[idx] == w) // verify
- ws[idx] = null;
- } finally {
- lock.unlock();
+ t = factory.newThread(this);
+ } catch (Throwable e) {
+ ex = e;
+ }
+ if (t == null) { // null or exceptional factory return
+ long c; // adjust counts
+ do {} while (!UNSAFE.compareAndSwapLong
+ (this, ctlOffset, c = ctl,
+ (((c - AC_UNIT) & AC_MASK) |
+ ((c - TC_UNIT) & TC_MASK) |
+ (c & ~(AC_MASK|TC_MASK)))));
+ // Propagate exception if originating from an external caller
+ if (!tryTerminate(false) && ex != null &&
+ !(Thread.currentThread() instanceof ForkJoinWorkerThread))
+ UNSAFE.throwException(ex);
+ }
+ else
+ t.start();
+ }
+
+ /**
+ * Callback from ForkJoinWorkerThread constructor to assign a
+ * public name
+ */
+ final String nextWorkerName() {
+ for (int n;;) {
+ if (UNSAFE.compareAndSwapInt(this, nextWorkerNumberOffset,
+ n = nextWorkerNumber, ++n))
+ return workerNamePrefix + n;
+ }
+ }
+
+ /**
+ * Callback from ForkJoinWorkerThread constructor to
+ * determine its poolIndex and record in workers array.
+ *
+ * @param w the worker
+ * @return the worker's pool index
+ */
+ final int registerWorker(ForkJoinWorkerThread w) {
+ /*
+ * In the typical case, a new worker acquires the lock, uses
+ * next available index and returns quickly. Since we should
+ * not block callers (ultimately from signalWork or
+ * tryPreBlock) waiting for the lock needed to do this, we
+ * instead help release other workers while waiting for the
+ * lock.
+ */
+ for (int g;;) {
+ ForkJoinWorkerThread[] ws;
+ if (((g = scanGuard) & SG_UNIT) == 0 &&
+ UNSAFE.compareAndSwapInt(this, scanGuardOffset,
+ g, g | SG_UNIT)) {
+ int k = nextWorkerIndex;
+ try {
+ if ((ws = workers) != null) { // ignore on shutdown
+ int n = ws.length;
+ if (k < 0 || k >= n || ws[k] != null) {
+ for (k = 0; k < n && ws[k] != null; ++k)
+ ;
+ if (k == n)
+ ws = workers = Arrays.copyOf(ws, n << 1);
+ }
+ ws[k] = w;
+ nextWorkerIndex = k + 1;
+ int m = g & SMASK;
+ g = k >= m? ((m << 1) + 1) & SMASK : g + (SG_UNIT<<1);
+ }
+ } finally {
+ scanGuard = g;
+ }
+ return k;
+ }
+ else if ((ws = workers) != null) { // help release others
+ for (ForkJoinWorkerThread u : ws) {
+ if (u != null && u.queueBase != u.queueTop) {
+ if (tryReleaseWaiter())
+ break;
+ }
+ }
+ }
}
}
@@ -743,415 +1200,46 @@
*
* @param w the worker
*/
- final void workerTerminated(ForkJoinWorkerThread w) {
- forgetWorker(w);
- decrementWorkerCounts(w.isTrimmed() ? 0 : ONE_RUNNING, ONE_TOTAL);
- while (w.stealCount != 0) // collect final count
- tryAccumulateStealCount(w);
- tryTerminate(false);
- }
-
- // Waiting for and signalling events
-
- /**
- * Releases workers blocked on a count not equal to current count.
- * Normally called after precheck that eventWaiters isn't zero to
- * avoid wasted array checks. Gives up upon a change in count or
- * upon releasing four workers, letting others take over.
- */
- private void releaseEventWaiters() {
- ForkJoinWorkerThread[] ws = workers;
- int n = ws.length;
- long h = eventWaiters;
- int ec = eventCount;
- int releases = 4;
- ForkJoinWorkerThread w; int id;
- while ((id = (((int)h) & WAITER_ID_MASK) - 1) >= 0 &&
- (int)(h >>> EVENT_COUNT_SHIFT) != ec &&
- id < n && (w = ws[id]) != null) {
- if (UNSAFE.compareAndSwapLong(this, eventWaitersOffset,
- h, w.nextWaiter)) {
- LockSupport.unpark(w);
- if (--releases == 0)
- break;
- }
- if (eventCount != ec)
- break;
- h = eventWaiters;
- }
- }
-
- /**
- * Tries to advance eventCount and releases waiters. Called only
- * from workers.
- */
- final void signalWork() {
- int c; // try to increment event count -- CAS failure OK
- UNSAFE.compareAndSwapInt(this, eventCountOffset, c = eventCount, c+1);
- if (eventWaiters != 0L)
- releaseEventWaiters();
- }
-
- /**
- * Adds the given worker to event queue and blocks until
- * terminating or event count advances from the given value
- *
- * @param w the calling worker thread
- * @param ec the count
- */
- private void eventSync(ForkJoinWorkerThread w, int ec) {
- long nh = (((long)ec) << EVENT_COUNT_SHIFT) | ((long)(w.poolIndex+1));
- long h;
- while ((runState < SHUTDOWN || !tryTerminate(false)) &&
- (((int)(h = eventWaiters) & WAITER_ID_MASK) == 0 ||
- (int)(h >>> EVENT_COUNT_SHIFT) == ec) &&
- eventCount == ec) {
- if (UNSAFE.compareAndSwapLong(this, eventWaitersOffset,
- w.nextWaiter = h, nh)) {
- awaitEvent(w, ec);
- break;
+ final void deregisterWorker(ForkJoinWorkerThread w, Throwable ex) {
+ int idx = w.poolIndex;
+ int sc = w.stealCount;
+ int steps = 0;
+ // Remove from array, adjust worker counts and collect steal count.
+ // We can intermix failed removes or adjusts with steal updates
+ do {
+ long s, c;
+ int g;
+ if (steps == 0 && ((g = scanGuard) & SG_UNIT) == 0 &&
+ UNSAFE.compareAndSwapInt(this, scanGuardOffset,
+ g, g |= SG_UNIT)) {
+ ForkJoinWorkerThread[] ws = workers;
+ if (ws != null && idx >= 0 &&
+ idx < ws.length && ws[idx] == w)
+ ws[idx] = null; // verify
+ nextWorkerIndex = idx;
+ scanGuard = g + SG_UNIT;
+ steps = 1;
}
- }
- }
-
- /**
- * Blocks the given worker (that has already been entered as an
- * event waiter) until terminating or event count advances from
- * the given value. The oldest (first) waiter uses a timed wait to
- * occasionally one-by-one shrink the number of workers (to a
- * minimum of one) if the pool has not been used for extended
- * periods.
- *
- * @param w the calling worker thread
- * @param ec the count
- */
- private void awaitEvent(ForkJoinWorkerThread w, int ec) {
- while (eventCount == ec) {
- if (tryAccumulateStealCount(w)) { // transfer while idle
- boolean untimed = (w.nextWaiter != 0L ||
- (workerCounts & RUNNING_COUNT_MASK) <= 1);
- long startTime = untimed ? 0 : System.nanoTime();
- Thread.interrupted(); // clear/ignore interrupt
- if (w.isTerminating() || eventCount != ec)
- break; // recheck after clear
- if (untimed)
- LockSupport.park(w);
- else {
- LockSupport.parkNanos(w, SHRINK_RATE_NANOS);
- if (eventCount != ec || w.isTerminating())
- break;
- if (System.nanoTime() - startTime >= SHRINK_RATE_NANOS)
- tryShutdownUnusedWorker(ec);
- }
- }
- }
- }
-
- // Maintaining parallelism
-
- /**
- * Pushes worker onto the spare stack.
- */
- final void pushSpare(ForkJoinWorkerThread w) {
- int ns = (++w.spareCount << SPARE_COUNT_SHIFT) | (w.poolIndex + 1);
- do {} while (!UNSAFE.compareAndSwapInt(this, spareWaitersOffset,
- w.nextSpare = spareWaiters,ns));
- }
-
- /**
- * Tries (once) to resume a spare if the number of running
- * threads is less than target.
- */
- private void tryResumeSpare() {
- int sw, id;
- ForkJoinWorkerThread[] ws = workers;
- int n = ws.length;
- ForkJoinWorkerThread w;
- if ((sw = spareWaiters) != 0 &&
- (id = (sw & SPARE_ID_MASK) - 1) >= 0 &&
- id < n && (w = ws[id]) != null &&
- (runState >= TERMINATING ||
- (workerCounts & RUNNING_COUNT_MASK) < parallelism) &&
- spareWaiters == sw &&
- UNSAFE.compareAndSwapInt(this, spareWaitersOffset,
- sw, w.nextSpare)) {
- int c; // increment running count before resume
- do {} while (!UNSAFE.compareAndSwapInt
- (this, workerCountsOffset,
- c = workerCounts, c + ONE_RUNNING));
- if (w.tryUnsuspend())
- LockSupport.unpark(w);
- else // back out if w was shutdown
- decrementWorkerCounts(ONE_RUNNING, 0);
+ if (steps == 1 &&
+ UNSAFE.compareAndSwapLong(this, ctlOffset, c = ctl,
+ (((c - AC_UNIT) & AC_MASK) |
+ ((c - TC_UNIT) & TC_MASK) |
+ (c & ~(AC_MASK|TC_MASK)))))
+ steps = 2;
+ if (sc != 0 &&
+ UNSAFE.compareAndSwapLong(this, stealCountOffset,
+ s = stealCount, s + sc))
+ sc = 0;
+ } while (steps != 2 || sc != 0);
+ if (!tryTerminate(false)) {
+ if (ex != null) // possibly replace if died abnormally
+ signalWork();
+ else
+ tryReleaseWaiter();
}
}
- /**
- * Tries to increase the number of running workers if below target
- * parallelism: If a spare exists tries to resume it via
- * tryResumeSpare. Otherwise, if not enough total workers or all
- * existing workers are busy, adds a new worker. In all cases also
- * helps wake up releasable workers waiting for work.
- */
- private void helpMaintainParallelism() {
- int pc = parallelism;
- int wc, rs, tc;
- while (((wc = workerCounts) & RUNNING_COUNT_MASK) < pc &&
- (rs = runState) < TERMINATING) {
- if (spareWaiters != 0)
- tryResumeSpare();
- else if ((tc = wc >>> TOTAL_COUNT_SHIFT) >= MAX_WORKERS ||
- (tc >= pc && (rs & ACTIVE_COUNT_MASK) != tc))
- break; // enough total
- else if (runState == rs && workerCounts == wc &&
- UNSAFE.compareAndSwapInt(this, workerCountsOffset, wc,
- wc + (ONE_RUNNING|ONE_TOTAL))) {
- ForkJoinWorkerThread w = null;
- Throwable fail = null;
- try {
- w = factory.newThread(this);
- } catch (Throwable ex) {
- fail = ex;
- }
- if (w == null) { // null or exceptional factory return
- decrementWorkerCounts(ONE_RUNNING, ONE_TOTAL);
- tryTerminate(false); // handle failure during shutdown
- // If originating from an external caller,
- // propagate exception, else ignore
- if (fail != null && runState < TERMINATING &&
- !(Thread.currentThread() instanceof
- ForkJoinWorkerThread))
- UNSAFE.throwException(fail);
- break;
- }
- w.start(recordWorker(w), ueh);
- if ((workerCounts >>> TOTAL_COUNT_SHIFT) >= pc)
- break; // add at most one unless total below target
- }
- }
- if (eventWaiters != 0L)
- releaseEventWaiters();
- }
-
- /**
- * Callback from the oldest waiter in awaitEvent waking up after a
- * period of non-use. If all workers are idle, tries (once) to
- * shutdown an event waiter or a spare, if one exists. Note that
- * we don't need CAS or locks here because the method is called
- * only from one thread occasionally waking (and even misfires are
- * OK). Note that until the shutdown worker fully terminates,
- * workerCounts will overestimate total count, which is tolerable.
- *
- * @param ec the event count waited on by caller (to abort
- * attempt if count has since changed).
- */
- private void tryShutdownUnusedWorker(int ec) {
- if (runState == 0 && eventCount == ec) { // only trigger if all idle
- ForkJoinWorkerThread[] ws = workers;
- int n = ws.length;
- ForkJoinWorkerThread w = null;
- boolean shutdown = false;
- int sw;
- long h;
- if ((sw = spareWaiters) != 0) { // prefer killing spares
- int id = (sw & SPARE_ID_MASK) - 1;
- if (id >= 0 && id < n && (w = ws[id]) != null &&
- UNSAFE.compareAndSwapInt(this, spareWaitersOffset,
- sw, w.nextSpare))
- shutdown = true;
- }
- else if ((h = eventWaiters) != 0L) {
- long nh;
- int id = (((int)h) & WAITER_ID_MASK) - 1;
- if (id >= 0 && id < n && (w = ws[id]) != null &&
- (nh = w.nextWaiter) != 0L && // keep at least one worker
- UNSAFE.compareAndSwapLong(this, eventWaitersOffset, h, nh))
- shutdown = true;
- }
- if (w != null && shutdown) {
- w.shutdown();
- LockSupport.unpark(w);
- }
- }
- releaseEventWaiters(); // in case of interference
- }
-
- /**
- * Callback from workers invoked upon each top-level action (i.e.,
- * stealing a task or taking a submission and running it).
- * Performs one or more of the following:
- *
- * 1. If the worker is active and either did not run a task
- * or there are too many workers, try to set its active status
- * to inactive and update activeCount. On contention, we may
- * try again in this or a subsequent call.
- *
- * 2. If not enough total workers, help create some.
- *
- * 3. If there are too many running workers, suspend this worker
- * (first forcing inactive if necessary). If it is not needed,
- * it may be shutdown while suspended (via
- * tryShutdownUnusedWorker). Otherwise, upon resume it
- * rechecks running thread count and need for event sync.
- *
- * 4. If worker did not run a task, await the next task event via
- * eventSync if necessary (first forcing inactivation), upon
- * which the worker may be shutdown via
- * tryShutdownUnusedWorker. Otherwise, help release any
- * existing event waiters that are now releasable,
- *
- * @param w the worker
- * @param ran true if worker ran a task since last call to this method
- */
- final void preStep(ForkJoinWorkerThread w, boolean ran) {
- int wec = w.lastEventCount;
- boolean active = w.active;
- boolean inactivate = false;
- int pc = parallelism;
- while (w.runState == 0) {
- int rs = runState;
- if (rs >= TERMINATING) { // propagate shutdown
- w.shutdown();
- break;
- }
- if ((inactivate || (active && (rs & ACTIVE_COUNT_MASK) >= pc)) &&
- UNSAFE.compareAndSwapInt(this, runStateOffset, rs, --rs)) {
- inactivate = active = w.active = false;
- if (rs == SHUTDOWN) { // all inactive and shut down
- tryTerminate(false);
- continue;
- }
- }
- int wc = workerCounts; // try to suspend as spare
- if ((wc & RUNNING_COUNT_MASK) > pc) {
- if (!(inactivate |= active) && // must inactivate to suspend
- workerCounts == wc &&
- UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc, wc - ONE_RUNNING))
- w.suspendAsSpare();
- }
- else if ((wc >>> TOTAL_COUNT_SHIFT) < pc)
- helpMaintainParallelism(); // not enough workers
- else if (ran)
- break;
- else {
- long h = eventWaiters;
- int ec = eventCount;
- if (h != 0L && (int)(h >>> EVENT_COUNT_SHIFT) != ec)
- releaseEventWaiters(); // release others before waiting
- else if (ec != wec) {
- w.lastEventCount = ec; // no need to wait
- break;
- }
- else if (!(inactivate |= active))
- eventSync(w, wec); // must inactivate before sync
- }
- }
- }
-
- /**
- * Helps and/or blocks awaiting join of the given task.
- * See above for explanation.
- *
- * @param joinMe the task to join
- * @param worker the current worker thread
- * @param timed true if wait should time out
- * @param nanos timeout value if timed
- */
- final void awaitJoin(ForkJoinTask<?> joinMe, ForkJoinWorkerThread worker,
- boolean timed, long nanos) {
- long startTime = timed ? System.nanoTime() : 0L;
- int retries = 2 + (parallelism >> 2); // #helpJoins before blocking
- boolean running = true; // false when count decremented
- while (joinMe.status >= 0) {
- if (runState >= TERMINATING) {
- joinMe.cancelIgnoringExceptions();
- break;
- }
- running = worker.helpJoinTask(joinMe, running);
- if (joinMe.status < 0)
- break;
- if (retries > 0) {
- --retries;
- continue;
- }
- int wc = workerCounts;
- if ((wc & RUNNING_COUNT_MASK) != 0) {
- if (running) {
- if (!UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc, wc - ONE_RUNNING))
- continue;
- running = false;
- }
- long h = eventWaiters;
- if (h != 0L && (int)(h >>> EVENT_COUNT_SHIFT) != eventCount)
- releaseEventWaiters();
- if ((workerCounts & RUNNING_COUNT_MASK) != 0) {
- long ms; int ns;
- if (!timed) {
- ms = JOIN_TIMEOUT_MILLIS;
- ns = 0;
- }
- else { // at most JOIN_TIMEOUT_MILLIS per wait
- long nt = nanos - (System.nanoTime() - startTime);
- if (nt <= 0L)
- break;
- ms = nt / 1000000;
- if (ms > JOIN_TIMEOUT_MILLIS) {
- ms = JOIN_TIMEOUT_MILLIS;
- ns = 0;
- }
- else
- ns = (int) (nt % 1000000);
- }
- joinMe.internalAwaitDone(ms, ns);
- }
- if (joinMe.status < 0)
- break;
- }
- helpMaintainParallelism();
- }
- if (!running) {
- int c;
- do {} while (!UNSAFE.compareAndSwapInt
- (this, workerCountsOffset,
- c = workerCounts, c + ONE_RUNNING));
- }
- }
-
- /**
- * Same idea as awaitJoin, but no helping, retries, or timeouts.
- */
- final void awaitBlocker(ManagedBlocker blocker)
- throws InterruptedException {
- while (!blocker.isReleasable()) {
- int wc = workerCounts;
- if ((wc & RUNNING_COUNT_MASK) == 0)
- helpMaintainParallelism();
- else if (UNSAFE.compareAndSwapInt(this, workerCountsOffset,
- wc, wc - ONE_RUNNING)) {
- try {
- while (!blocker.isReleasable()) {
- long h = eventWaiters;
- if (h != 0L &&
- (int)(h >>> EVENT_COUNT_SHIFT) != eventCount)
- releaseEventWaiters();
- else if ((workerCounts & RUNNING_COUNT_MASK) == 0 &&
- runState < TERMINATING)
- helpMaintainParallelism();
- else if (blocker.block())
- break;
- }
- } finally {
- int c;
- do {} while (!UNSAFE.compareAndSwapInt
- (this, workerCountsOffset,
- c = workerCounts, c + ONE_RUNNING));
- }
- break;
- }
- }
- }
+ // Shutdown and termination
/**
* Possibly initiates and/or completes termination.
@@ -1161,97 +1249,132 @@
* @return true if now terminating or terminated
*/
private boolean tryTerminate(boolean now) {
- if (now)
- advanceRunLevel(SHUTDOWN); // ensure at least SHUTDOWN
- else if (runState < SHUTDOWN ||
- !submissionQueue.isEmpty() ||
- (runState & ACTIVE_COUNT_MASK) != 0)
- return false;
-
- if (advanceRunLevel(TERMINATING))
- startTerminating();
-
- // Finish now if all threads terminated; else in some subsequent call
- if ((workerCounts >>> TOTAL_COUNT_SHIFT) == 0) {
- advanceRunLevel(TERMINATED);
- termination.forceTermination();
+ long c;
+ while (((c = ctl) & STOP_BIT) == 0) {
+ if (!now) {
+ if ((int)(c >> AC_SHIFT) != -parallelism)
+ return false;
+ if (!shutdown || blockedCount != 0 || quiescerCount != 0 ||
+ queueBase != queueTop) {
+ if (ctl == c) // staleness check
+ return false;
+ continue;
+ }
+ }
+ if (UNSAFE.compareAndSwapLong(this, ctlOffset, c, c | STOP_BIT))
+ startTerminating();
+ }
+ if ((short)(c >>> TC_SHIFT) == -parallelism) { // signal when 0 workers
+ final ReentrantLock lock = this.submissionLock;
+ lock.lock();
+ try {
+ termination.signalAll();
+ } finally {
+ lock.unlock();
+ }
}
return true;
}
/**
- * Actions on transition to TERMINATING
- *
- * Runs up to four passes through workers: (0) shutting down each
- * (without waking up if parked) to quickly spread notifications
- * without unnecessary bouncing around event queues etc (1) wake
- * up and help cancel tasks (2) interrupt (3) mop up races with
- * interrupted workers
+ * Runs up to three passes through workers: (0) Setting
+ * termination status for each worker, followed by wakeups up to
+ * queued workers; (1) helping cancel tasks; (2) interrupting
+ * lagging threads (likely in external tasks, but possibly also
+ * blocked in joins). Each pass repeats previous steps because of
+ * potential lagging thread creation.
*/
private void startTerminating() {
cancelSubmissions();
- for (int passes = 0; passes < 4 && workerCounts != 0; ++passes) {
- int c; // advance event count
- UNSAFE.compareAndSwapInt(this, eventCountOffset,
- c = eventCount, c+1);
- eventWaiters = 0L; // clobber lists
- spareWaiters = 0;
- for (ForkJoinWorkerThread w : workers) {
- if (w != null) {
- w.shutdown();
- if (passes > 0 && !w.isTerminated()) {
- w.cancelTasks();
- LockSupport.unpark(w);
- if (passes > 1 && !w.isInterrupted()) {
- try {
- w.interrupt();
- } catch (SecurityException ignore) {
+ for (int pass = 0; pass < 3; ++pass) {
+ ForkJoinWorkerThread[] ws = workers;
+ if (ws != null) {
+ for (ForkJoinWorkerThread w : ws) {
+ if (w != null) {
+ w.terminate = true;
+ if (pass > 0) {
+ w.cancelTasks();
+ if (pass > 1 && !w.isInterrupted()) {
+ try {
+ w.interrupt();
+ } catch (SecurityException ignore) {
+ }
}
}
}
}
+ terminateWaiters();
+ }
+ }
+ }
+
+ /**
+ * Polls and cancels all submissions. Called only during termination.
+ */
+ private void cancelSubmissions() {
+ while (queueBase != queueTop) {
+ ForkJoinTask<?> task = pollSubmission();
+ if (task != null) {
+ try {
+ task.cancel(false);
+ } catch (Throwable ignore) {
+ }
}
}
}
/**
- * Clears out and cancels submissions, ignoring exceptions.
+ * Tries to set the termination status of waiting workers, and
+ * then wakes them up (after which they will terminate).
*/
- private void cancelSubmissions() {
- ForkJoinTask<?> task;
- while ((task = submissionQueue.poll()) != null) {
- try {
- task.cancel(false);
- } catch (Throwable ignore) {
+ private void terminateWaiters() {
+ ForkJoinWorkerThread[] ws = workers;
+ if (ws != null) {
+ ForkJoinWorkerThread w; long c; int i, e;
+ int n = ws.length;
+ while ((i = ~(e = (int)(c = ctl)) & SMASK) < n &&
+ (w = ws[i]) != null && w.eventCount == (e & E_MASK)) {
+ if (UNSAFE.compareAndSwapLong(this, ctlOffset, c,
+ (long)(w.nextWait & E_MASK) |
+ ((c + AC_UNIT) & AC_MASK) |
+ (c & (TC_MASK|STOP_BIT)))) {
+ w.terminate = true;
+ w.eventCount = e + EC_UNIT;
+ if (w.parked)
+ UNSAFE.unpark(w);
+ }
}
}
}
- // misc support for ForkJoinWorkerThread
+ // misc ForkJoinWorkerThread support
/**
- * Returns pool number.
+ * Increment or decrement quiescerCount. Needed only to prevent
+ * triggering shutdown if a worker is transiently inactive while
+ * checking quiescence.
+ *
+ * @param delta 1 for increment, -1 for decrement
*/
- final int getPoolNumber() {
- return poolNumber;
+ final void addQuiescerCount(int delta) {
+ int c;
+ do {} while(!UNSAFE.compareAndSwapInt(this, quiescerCountOffset,
+ c = quiescerCount, c + delta));
}
/**
- * Tries to accumulate steal count from a worker, clearing
- * the worker's value if successful.
+ * Directly increment or decrement active count without
+ * queuing. This method is used to transiently assert inactivation
+ * while checking quiescence.
*
- * @return true if worker steal count now zero
+ * @param delta 1 for increment, -1 for decrement
*/
- final boolean tryAccumulateStealCount(ForkJoinWorkerThread w) {
- int sc = w.stealCount;
- long c = stealCount;
- // CAS even if zero, for fence effects
- if (UNSAFE.compareAndSwapLong(this, stealCountOffset, c, c + sc)) {
- if (sc != 0)
- w.stealCount = 0;
- return true;
- }
- return sc == 0;
+ final void addActiveCount(int delta) {
+ long d = delta < 0 ? -AC_UNIT : AC_UNIT;
+ long c;
+ do {} while (!UNSAFE.compareAndSwapLong(this, ctlOffset, c = ctl,
+ ((c + d) & AC_MASK) |
+ (c & ~AC_MASK)));
}
/**
@@ -1259,16 +1382,17 @@
* active thread.
*/
final int idlePerActive() {
- int pc = parallelism; // use parallelism, not rc
- int ac = runState; // no mask -- artificially boosts during shutdown
- // Use exact results for small values, saturate past 4
- return ((pc <= ac) ? 0 :
- (pc >>> 1 <= ac) ? 1 :
- (pc >>> 2 <= ac) ? 3 :
- pc >>> 3);
+ // Approximate at powers of two for small values, saturate past 4
+ int p = parallelism;
+ int a = p + (int)(ctl >> AC_SHIFT);
+ return (a > (p >>>= 1) ? 0 :
+ a > (p >>>= 1) ? 1 :
+ a > (p >>>= 1) ? 2 :
+ a > (p >>>= 1) ? 4 :
+ 8);
}
- // Public and protected methods
+ // Exported methods
// Constructors
@@ -1337,49 +1461,42 @@
checkPermission();
if (factory == null)
throw new NullPointerException();
- if (parallelism <= 0 || parallelism > MAX_WORKERS)
+ if (parallelism <= 0 || parallelism > MAX_ID)
throw new IllegalArgumentException();
this.parallelism = parallelism;
this.factory = factory;
this.ueh = handler;
this.locallyFifo = asyncMode;
- int arraySize = initialArraySizeFor(parallelism);
- this.workers = new ForkJoinWorkerThread[arraySize];
- this.submissionQueue = new LinkedTransferQueue<ForkJoinTask<?>>();
- this.workerLock = new ReentrantLock();
- this.termination = new Phaser(1);
- this.poolNumber = poolNumberGenerator.incrementAndGet();
- }
-
- /**
- * Returns initial power of two size for workers array.
- * @param pc the initial parallelism level
- */
- private static int initialArraySizeFor(int pc) {
- // If possible, initially allocate enough space for one spare
- int size = pc < MAX_WORKERS ? pc + 1 : MAX_WORKERS;
- // See Hackers Delight, sec 3.2. We know MAX_WORKERS < (1 >>> 16)
- size |= size >>> 1;
- size |= size >>> 2;
- size |= size >>> 4;
- size |= size >>> 8;
- return size + 1;
+ long np = (long)(-parallelism); // offset ctl counts
+ this.ctl = ((np << AC_SHIFT) & AC_MASK) | ((np << TC_SHIFT) & TC_MASK);
+ this.submissionQueue = new ForkJoinTask<?>[INITIAL_QUEUE_CAPACITY];
+ // initialize workers array with room for 2*parallelism if possible
+ int n = parallelism << 1;
+ if (n >= MAX_ID)
+ n = MAX_ID;
+ else { // See Hackers Delight, sec 3.2, where n < (1 << 16)
+ n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8;
+ }
+ workers = new ForkJoinWorkerThread[n + 1];
+ this.submissionLock = new ReentrantLock();
+ this.termination = submissionLock.newCondition();
+ StringBuilder sb = new StringBuilder("ForkJoinPool-");
+ sb.append(poolNumberGenerator.incrementAndGet());
+ sb.append("-worker-");
+ this.workerNamePrefix = sb.toString();
}
// Execution methods
/**
- * Submits task and creates, starts, or resumes some workers if necessary
- */
- private <T> void doSubmit(ForkJoinTask<T> task) {
- submissionQueue.offer(task);
- int c; // try to increment event count -- CAS failure OK
- UNSAFE.compareAndSwapInt(this, eventCountOffset, c = eventCount, c+1);
- helpMaintainParallelism();
- }
-
- /**
* Performs the given task, returning its result upon completion.
+ * If the computation encounters an unchecked Exception or Error,
+ * it is rethrown as the outcome of this invocation. Rethrown
+ * exceptions behave in the same way as regular exceptions, but,
+ * when possible, contain stack traces (as displayed for example
+ * using {@code ex.printStackTrace()}) of both the current thread
+ * as well as the thread actually encountering the exception;
+ * minimally only the latter.
*
* @param task the task
* @return the task's result
@@ -1388,16 +1505,16 @@
* scheduled for execution
*/
public <T> T invoke(ForkJoinTask<T> task) {
+ Thread t = Thread.currentThread();
if (task == null)
throw new NullPointerException();
- if (runState >= SHUTDOWN)
+ if (shutdown)
throw new RejectedExecutionException();
- Thread t = Thread.currentThread();
if ((t instanceof ForkJoinWorkerThread) &&
((ForkJoinWorkerThread)t).pool == this)
return task.invoke(); // bypass submit if in same pool
else {
- doSubmit(task);
+ addSubmission(task);
return task.join();
}
}
@@ -1407,14 +1524,15 @@
* computation in the current pool, else submits as external task.
*/
private <T> void forkOrSubmit(ForkJoinTask<T> task) {
- if (runState >= SHUTDOWN)
+ ForkJoinWorkerThread w;
+ Thread t = Thread.currentThread();
+ if (shutdown)
throw new RejectedExecutionException();
- Thread t = Thread.currentThread();
if ((t instanceof ForkJoinWorkerThread) &&
- ((ForkJoinWorkerThread)t).pool == this)
- task.fork();
+ (w = (ForkJoinWorkerThread)t).pool == this)
+ w.pushTask(task);
else
- doSubmit(task);
+ addSubmission(task);
}
/**
@@ -1571,7 +1689,7 @@
* @return the number of worker threads
*/
public int getPoolSize() {
- return workerCounts >>> TOTAL_COUNT_SHIFT;
+ return parallelism + (short)(ctl >>> TC_SHIFT);
}
/**
@@ -1593,7 +1711,8 @@
* @return the number of worker threads
*/
public int getRunningThreadCount() {
- return workerCounts & RUNNING_COUNT_MASK;
+ int r = parallelism + (int)(ctl >> AC_SHIFT);
+ return r <= 0? 0 : r; // suppress momentarily negative values
}
/**
@@ -1604,7 +1723,8 @@
* @return the number of active threads
*/
public int getActiveThreadCount() {
- return runState & ACTIVE_COUNT_MASK;
+ int r = parallelism + (int)(ctl >> AC_SHIFT) + blockedCount;
+ return r <= 0? 0 : r; // suppress momentarily negative values
}
/**
@@ -1619,7 +1739,7 @@
* @return {@code true} if all threads are currently idle
*/
public boolean isQuiescent() {
- return (runState & ACTIVE_COUNT_MASK) == 0;
+ return parallelism + (int)(ctl >> AC_SHIFT) + blockedCount == 0;
}
/**
@@ -1649,21 +1769,25 @@
*/
public long getQueuedTaskCount() {
long count = 0;
- for (ForkJoinWorkerThread w : workers)
- if (w != null)
- count += w.getQueueSize();
+ ForkJoinWorkerThread[] ws;
+ if ((short)(ctl >>> TC_SHIFT) > -parallelism &&
+ (ws = workers) != null) {
+ for (ForkJoinWorkerThread w : ws)
+ if (w != null)
+ count -= w.queueBase - w.queueTop; // must read base first
+ }
return count;
}
/**
* Returns an estimate of the number of tasks submitted to this
- * pool that have not yet begun executing. This method takes time
- * proportional to the number of submissions.
+ * pool that have not yet begun executing. This method may take
+ * time proportional to the number of submissions.
*
* @return the number of queued submissions
*/
public int getQueuedSubmissionCount() {
- return submissionQueue.size();
+ return -queueBase + queueTop;
}
/**
@@ -1673,7 +1797,7 @@
* @return {@code true} if there are any queued submissions
*/
public boolean hasQueuedSubmissions() {
- return !submissionQueue.isEmpty();
+ return queueBase != queueTop;
}
/**
@@ -1684,7 +1808,19 @@
* @return the next submission, or {@code null} if none
*/
protected ForkJoinTask<?> pollSubmission() {
- return submissionQueue.poll();
+ ForkJoinTask<?> t; ForkJoinTask<?>[] q; int b, i;
+ while ((b = queueBase) != queueTop &&
+ (q = submissionQueue) != null &&
+ (i = (q.length - 1) & b) >= 0) {
+ long u = (i << ASHIFT) + ABASE;
+ if ((t = q[i]) != null &&
+ queueBase == b &&
+ UNSAFE.compareAndSwapObject(q, u, t, null)) {
+ queueBase = b + 1;
+ return t;
+ }
+ }
+ return null;
}
/**
@@ -1705,10 +1841,21 @@
* @return the number of elements transferred
*/
protected int drainTasksTo(Collection<? super ForkJoinTask<?>> c) {
- int count = submissionQueue.drainTo(c);
- for (ForkJoinWorkerThread w : workers)
- if (w != null)
- count += w.drainTasksTo(c);
+ int count = 0;
+ while (queueBase != queueTop) {
+ ForkJoinTask<?> t = pollSubmission();
+ if (t != null) {
+ c.add(t);
+ ++count;
+ }
+ }
+ ForkJoinWorkerThread[] ws;
+ if ((short)(ctl >>> TC_SHIFT) > -parallelism &&
+ (ws = workers) != null) {
+ for (ForkJoinWorkerThread w : ws)
+ if (w != null)
+ count += w.drainTasksTo(c);
+ }
return count;
}
@@ -1723,14 +1870,20 @@
long st = getStealCount();
long qt = getQueuedTaskCount();
long qs = getQueuedSubmissionCount();
- int wc = workerCounts;
- int tc = wc >>> TOTAL_COUNT_SHIFT;
- int rc = wc & RUNNING_COUNT_MASK;
int pc = parallelism;
- int rs = runState;
- int ac = rs & ACTIVE_COUNT_MASK;
+ long c = ctl;
+ int tc = pc + (short)(c >>> TC_SHIFT);
+ int rc = pc + (int)(c >> AC_SHIFT);
+ if (rc < 0) // ignore transient negative
+ rc = 0;
+ int ac = rc + blockedCount;
+ String level;
+ if ((c & STOP_BIT) != 0)
+ level = (tc == 0)? "Terminated" : "Terminating";
+ else
+ level = shutdown? "Shutting down" : "Running";
return super.toString() +
- "[" + runLevelToString(rs) +
+ "[" + level +
", parallelism = " + pc +
", size = " + tc +
", active = " + ac +
@@ -1741,13 +1894,6 @@
"]";
}
- private static String runLevelToString(int s) {
- return ((s & TERMINATED) != 0 ? "Terminated" :
- ((s & TERMINATING) != 0 ? "Terminating" :
- ((s & SHUTDOWN) != 0 ? "Shutting down" :
- "Running")));
- }
-
/**
* Initiates an orderly shutdown in which previously submitted
* tasks are executed, but no new tasks will be accepted.
@@ -1762,7 +1908,7 @@
*/
public void shutdown() {
checkPermission();
- advanceRunLevel(SHUTDOWN);
+ shutdown = true;
tryTerminate(false);
}
@@ -1784,6 +1930,7 @@
*/
public List<Runnable> shutdownNow() {
checkPermission();
+ shutdown = true;
tryTerminate(true);
return Collections.emptyList();
}
@@ -1794,7 +1941,9 @@
* @return {@code true} if all tasks have completed following shut down
*/
public boolean isTerminated() {
- return runState >= TERMINATED;
+ long c = ctl;
+ return ((c & STOP_BIT) != 0L &&
+ (short)(c >>> TC_SHIFT) == -parallelism);
}
/**
@@ -1811,14 +1960,16 @@
* @return {@code true} if terminating but not yet terminated
*/
public boolean isTerminating() {
- return (runState & (TERMINATING|TERMINATED)) == TERMINATING;
+ long c = ctl;
+ return ((c & STOP_BIT) != 0L &&
+ (short)(c >>> TC_SHIFT) != -parallelism);
}
/**
* Returns true if terminating or terminated. Used by ForkJoinWorkerThread.
*/
final boolean isAtLeastTerminating() {
- return runState >= TERMINATING;
+ return (ctl & STOP_BIT) != 0L;
}
/**
@@ -1827,7 +1978,7 @@
* @return {@code true} if this pool has been shut down
*/
public boolean isShutdown() {
- return runState >= SHUTDOWN;
+ return shutdown;
}
/**
@@ -1843,12 +1994,20 @@
*/
public boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException {
+ long nanos = unit.toNanos(timeout);
+ final ReentrantLock lock = this.submissionLock;
+ lock.lock();
try {
- termination.awaitAdvanceInterruptibly(0, timeout, unit);
- } catch (TimeoutException ex) {
- return false;
+ for (;;) {
+ if (isTerminated())
+ return true;
+ if (nanos <= 0)
+ return false;
+ nanos = termination.awaitNanos(nanos);
+ }
+ } finally {
+ lock.unlock();
}
- return true;
}
/**
@@ -1859,13 +2018,15 @@
* {@code isReleasable} must return {@code true} if blocking is
* not necessary. Method {@code block} blocks the current thread
* if necessary (perhaps internally invoking {@code isReleasable}
- * before actually blocking). The unusual methods in this API
- * accommodate synchronizers that may, but don't usually, block
- * for long periods. Similarly, they allow more efficient internal
- * handling of cases in which additional workers may be, but
- * usually are not, needed to ensure sufficient parallelism.
- * Toward this end, implementations of method {@code isReleasable}
- * must be amenable to repeated invocation.
+ * before actually blocking). These actions are performed by any
+ * thread invoking {@link ForkJoinPool#managedBlock}. The
+ * unusual methods in this API accommodate synchronizers that may,
+ * but don't usually, block for long periods. Similarly, they
+ * allow more efficient internal handling of cases in which
+ * additional workers may be, but usually are not, needed to
+ * ensure sufficient parallelism. Toward this end,
+ * implementations of method {@code isReleasable} must be amenable
+ * to repeated invocation.
*
* <p>For example, here is a ManagedBlocker based on a
* ReentrantLock:
@@ -1967,29 +2128,47 @@
}
// Unsafe mechanics
+ private static final sun.misc.Unsafe UNSAFE;
+ private static final long ctlOffset;
+ private static final long stealCountOffset;
+ private static final long blockedCountOffset;
+ private static final long quiescerCountOffset;
+ private static final long scanGuardOffset;
+ private static final long nextWorkerNumberOffset;
+ private static final long ABASE;
+ private static final int ASHIFT;
- private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
- private static final long workerCountsOffset =
- objectFieldOffset("workerCounts", ForkJoinPool.class);
- private static final long runStateOffset =
- objectFieldOffset("runState", ForkJoinPool.class);
- private static final long eventCountOffset =
- objectFieldOffset("eventCount", ForkJoinPool.class);
- private static final long eventWaitersOffset =
- objectFieldOffset("eventWaiters", ForkJoinPool.class);
- private static final long stealCountOffset =
- objectFieldOffset("stealCount", ForkJoinPool.class);
- private static final long spareWaitersOffset =
- objectFieldOffset("spareWaiters", ForkJoinPool.class);
+ static {
+ poolNumberGenerator = new AtomicInteger();
+ workerSeedGenerator = new Random();
+ modifyThreadPermission = new RuntimePermission("modifyThread");
+ defaultForkJoinWorkerThreadFactory =
+ new DefaultForkJoinWorkerThreadFactory();
+ int s;
+ try {
+ UNSAFE = sun.misc.Unsafe.getUnsafe();
+ Class k = ForkJoinPool.class;
+ ctlOffset = UNSAFE.objectFieldOffset
+ (k.getDeclaredField("ctl"));
+ stealCountOffset = UNSAFE.objectFieldOffset
+ (k.getDeclaredField("stealCount"));
+ blockedCountOffset = UNSAFE.objectFieldOffset
+ (k.getDeclaredField("blockedCount"));
+ quiescerCountOffset = UNSAFE.objectFieldOffset
+ (k.getDeclaredField("quiescerCount"));
+ scanGuardOffset = UNSAFE.objectFieldOffset
+ (k.getDeclaredField("scanGuard"));
+ nextWorkerNumberOffset = UNSAFE.objectFieldOffset
+ (k.getDeclaredField("nextWorkerNumber"));
+ Class a = ForkJoinTask[].class;
+ ABASE = UNSAFE.arrayBaseOffset(a);
+ s = UNSAFE.arrayIndexScale(a);
+ } catch (Exception e) {
+ throw new Error(e);
+ }
+ if ((s & (s-1)) != 0)
+ throw new Error("data type scale not a power of two");
+ ASHIFT = 31 - Integer.numberOfLeadingZeros(s);
+ }
- private static long objectFieldOffset(String field, Class<?> klazz) {
- try {
- return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
- } catch (NoSuchFieldException e) {
- // Convert Exception to corresponding Error
- NoSuchFieldError error = new NoSuchFieldError(field);
- error.initCause(e);
- throw error;
- }
- }
}
--- a/jdk/src/share/classes/java/util/concurrent/ForkJoinTask.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/util/concurrent/ForkJoinTask.java Mon Mar 21 16:57:18 2011 -0700
@@ -41,7 +41,8 @@
import java.util.List;
import java.util.RandomAccess;
import java.util.Map;
-import java.util.WeakHashMap;
+import java.lang.ref.WeakReference;
+import java.lang.ref.ReferenceQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
@@ -52,6 +53,8 @@
import java.util.concurrent.RunnableFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
+import java.util.concurrent.locks.ReentrantLock;
+import java.lang.reflect.Constructor;
/**
* Abstract base class for tasks that run within a {@link ForkJoinPool}.
@@ -95,7 +98,11 @@
* rethrown to callers attempting to join them. These exceptions may
* additionally include {@link RejectedExecutionException} stemming
* from internal resource exhaustion, such as failure to allocate
- * internal task queues.
+ * internal task queues. Rethrown exceptions behave in the same way as
+ * regular exceptions, but, when possible, contain stack traces (as
+ * displayed for example using {@code ex.printStackTrace()}) of both
+ * the thread that initiated the computation as well as the thread
+ * actually encountering the exception; minimally only the latter.
*
* <p>The primary method for awaiting completion and extracting
* results of a task is {@link #join}, but there are several variants:
@@ -192,8 +199,7 @@
* status maintenance (2) execution and awaiting completion (3)
* user-level methods that additionally report results. This is
* sometimes hard to see because this file orders exported methods
- * in a way that flows well in javadocs. In particular, most
- * join mechanics are in method quietlyJoin, below.
+ * in a way that flows well in javadocs.
*/
/*
@@ -215,91 +221,67 @@
/** The run status of this task */
volatile int status; // accessed directly by pool and workers
-
private static final int NORMAL = -1;
private static final int CANCELLED = -2;
private static final int EXCEPTIONAL = -3;
private static final int SIGNAL = 1;
/**
- * Table of exceptions thrown by tasks, to enable reporting by
- * callers. Because exceptions are rare, we don't directly keep
- * them with task objects, but instead use a weak ref table. Note
- * that cancellation exceptions don't appear in the table, but are
- * instead recorded as status values.
- * TODO: Use ConcurrentReferenceHashMap
- */
- static final Map<ForkJoinTask<?>, Throwable> exceptionMap =
- Collections.synchronizedMap
- (new WeakHashMap<ForkJoinTask<?>, Throwable>());
-
- // Maintaining completion status
-
- /**
* Marks completion and wakes up threads waiting to join this task,
* also clearing signal request bits.
*
* @param completion one of NORMAL, CANCELLED, EXCEPTIONAL
+ * @return completion status on exit
*/
- private void setCompletion(int completion) {
- int s;
- while ((s = status) >= 0) {
+ private int setCompletion(int completion) {
+ for (int s;;) {
+ if ((s = status) < 0)
+ return s;
if (UNSAFE.compareAndSwapInt(this, statusOffset, s, completion)) {
if (s != 0)
synchronized (this) { notifyAll(); }
- break;
+ return completion;
}
}
}
/**
- * Records exception and sets exceptional completion.
+ * Tries to block a worker thread until completed or timed out.
+ * Uses Object.wait time argument conventions.
+ * May fail on contention or interrupt.
*
- * @return status on exit
+ * @param millis if > 0, wait time.
*/
- private void setExceptionalCompletion(Throwable rex) {
- exceptionMap.put(this, rex);
- setCompletion(EXCEPTIONAL);
- }
-
- /**
- * Blocks a worker thread until completed or timed out. Called
- * only by pool.
- */
- final void internalAwaitDone(long millis, int nanos) {
- int s = status;
- if ((s == 0 &&
- UNSAFE.compareAndSwapInt(this, statusOffset, 0, SIGNAL)) ||
- s > 0) {
- try { // the odd construction reduces lock bias effects
+ final void tryAwaitDone(long millis) {
+ int s;
+ try {
+ if (((s = status) > 0 ||
+ (s == 0 &&
+ UNSAFE.compareAndSwapInt(this, statusOffset, 0, SIGNAL))) &&
+ status > 0) {
synchronized (this) {
if (status > 0)
- wait(millis, nanos);
- else
- notifyAll();
+ wait(millis);
}
- } catch (InterruptedException ie) {
- cancelIfTerminating();
}
+ } catch (InterruptedException ie) {
+ // caller must check termination
}
}
/**
* Blocks a non-worker-thread until completion.
+ * @return status upon completion
*/
- private void externalAwaitDone() {
- if (status >= 0) {
+ private int externalAwaitDone() {
+ int s;
+ if ((s = status) >= 0) {
boolean interrupted = false;
synchronized (this) {
- for (;;) {
- int s = status;
+ while ((s = status) >= 0) {
if (s == 0)
UNSAFE.compareAndSwapInt(this, statusOffset,
0, SIGNAL);
- else if (s < 0) {
- notifyAll();
- break;
- }
else {
try {
wait();
@@ -312,53 +294,308 @@
if (interrupted)
Thread.currentThread().interrupt();
}
+ return s;
}
/**
* Blocks a non-worker-thread until completion or interruption or timeout.
*/
- private void externalInterruptibleAwaitDone(boolean timed, long nanos)
+ private int externalInterruptibleAwaitDone(long millis)
throws InterruptedException {
+ int s;
if (Thread.interrupted())
throw new InterruptedException();
- if (status >= 0) {
- long startTime = timed ? System.nanoTime() : 0L;
+ if ((s = status) >= 0) {
synchronized (this) {
- for (;;) {
- long nt;
- int s = status;
+ while ((s = status) >= 0) {
if (s == 0)
UNSAFE.compareAndSwapInt(this, statusOffset,
0, SIGNAL);
- else if (s < 0) {
- notifyAll();
+ else {
+ wait(millis);
+ if (millis > 0L)
+ break;
+ }
+ }
+ }
+ }
+ return s;
+ }
+
+ /**
+ * Primary execution method for stolen tasks. Unless done, calls
+ * exec and records status if completed, but doesn't wait for
+ * completion otherwise.
+ */
+ final void doExec() {
+ if (status >= 0) {
+ boolean completed;
+ try {
+ completed = exec();
+ } catch (Throwable rex) {
+ setExceptionalCompletion(rex);
+ return;
+ }
+ if (completed)
+ setCompletion(NORMAL); // must be outside try block
+ }
+ }
+
+ /**
+ * Primary mechanics for join, get, quietlyJoin.
+ * @return status upon completion
+ */
+ private int doJoin() {
+ Thread t; ForkJoinWorkerThread w; int s; boolean completed;
+ if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) {
+ if ((s = status) < 0)
+ return s;
+ if ((w = (ForkJoinWorkerThread)t).unpushTask(this)) {
+ try {
+ completed = exec();
+ } catch (Throwable rex) {
+ return setExceptionalCompletion(rex);
+ }
+ if (completed)
+ return setCompletion(NORMAL);
+ }
+ return w.joinTask(this);
+ }
+ else
+ return externalAwaitDone();
+ }
+
+ /**
+ * Primary mechanics for invoke, quietlyInvoke.
+ * @return status upon completion
+ */
+ private int doInvoke() {
+ int s; boolean completed;
+ if ((s = status) < 0)
+ return s;
+ try {
+ completed = exec();
+ } catch (Throwable rex) {
+ return setExceptionalCompletion(rex);
+ }
+ if (completed)
+ return setCompletion(NORMAL);
+ else
+ return doJoin();
+ }
+
+ // Exception table support
+
+ /**
+ * Table of exceptions thrown by tasks, to enable reporting by
+ * callers. Because exceptions are rare, we don't directly keep
+ * them with task objects, but instead use a weak ref table. Note
+ * that cancellation exceptions don't appear in the table, but are
+ * instead recorded as status values.
+ *
+ * Note: These statics are initialized below in static block.
+ */
+ private static final ExceptionNode[] exceptionTable;
+ private static final ReentrantLock exceptionTableLock;
+ private static final ReferenceQueue<Object> exceptionTableRefQueue;
+
+ /**
+ * Fixed capacity for exceptionTable.
+ */
+ private static final int EXCEPTION_MAP_CAPACITY = 32;
+
+ /**
+ * Key-value nodes for exception table. The chained hash table
+ * uses identity comparisons, full locking, and weak references
+ * for keys. The table has a fixed capacity because it only
+ * maintains task exceptions long enough for joiners to access
+ * them, so should never become very large for sustained
+ * periods. However, since we do not know when the last joiner
+ * completes, we must use weak references and expunge them. We do
+ * so on each operation (hence full locking). Also, some thread in
+ * any ForkJoinPool will call helpExpungeStaleExceptions when its
+ * pool becomes isQuiescent.
+ */
+ static final class ExceptionNode extends WeakReference<ForkJoinTask<?>>{
+ final Throwable ex;
+ ExceptionNode next;
+ final long thrower; // use id not ref to avoid weak cycles
+ ExceptionNode(ForkJoinTask<?> task, Throwable ex, ExceptionNode next) {
+ super(task, exceptionTableRefQueue);
+ this.ex = ex;
+ this.next = next;
+ this.thrower = Thread.currentThread().getId();
+ }
+ }
+
+ /**
+ * Records exception and sets exceptional completion.
+ *
+ * @return status on exit
+ */
+ private int setExceptionalCompletion(Throwable ex) {
+ int h = System.identityHashCode(this);
+ final ReentrantLock lock = exceptionTableLock;
+ lock.lock();
+ try {
+ expungeStaleExceptions();
+ ExceptionNode[] t = exceptionTable;
+ int i = h & (t.length - 1);
+ for (ExceptionNode e = t[i]; ; e = e.next) {
+ if (e == null) {
+ t[i] = new ExceptionNode(this, ex, t[i]);
+ break;
+ }
+ if (e.get() == this) // already present
+ break;
+ }
+ } finally {
+ lock.unlock();
+ }
+ return setCompletion(EXCEPTIONAL);
+ }
+
+ /**
+ * Removes exception node and clears status
+ */
+ private void clearExceptionalCompletion() {
+ int h = System.identityHashCode(this);
+ final ReentrantLock lock = exceptionTableLock;
+ lock.lock();
+ try {
+ ExceptionNode[] t = exceptionTable;
+ int i = h & (t.length - 1);
+ ExceptionNode e = t[i];
+ ExceptionNode pred = null;
+ while (e != null) {
+ ExceptionNode next = e.next;
+ if (e.get() == this) {
+ if (pred == null)
+ t[i] = next;
+ else
+ pred.next = next;
+ break;
+ }
+ pred = e;
+ e = next;
+ }
+ expungeStaleExceptions();
+ status = 0;
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ /**
+ * Returns a rethrowable exception for the given task, if
+ * available. To provide accurate stack traces, if the exception
+ * was not thrown by the current thread, we try to create a new
+ * exception of the same type as the one thrown, but with the
+ * recorded exception as its cause. If there is no such
+ * constructor, we instead try to use a no-arg constructor,
+ * followed by initCause, to the same effect. If none of these
+ * apply, or any fail due to other exceptions, we return the
+ * recorded exception, which is still correct, although it may
+ * contain a misleading stack trace.
+ *
+ * @return the exception, or null if none
+ */
+ private Throwable getThrowableException() {
+ if (status != EXCEPTIONAL)
+ return null;
+ int h = System.identityHashCode(this);
+ ExceptionNode e;
+ final ReentrantLock lock = exceptionTableLock;
+ lock.lock();
+ try {
+ expungeStaleExceptions();
+ ExceptionNode[] t = exceptionTable;
+ e = t[h & (t.length - 1)];
+ while (e != null && e.get() != this)
+ e = e.next;
+ } finally {
+ lock.unlock();
+ }
+ Throwable ex;
+ if (e == null || (ex = e.ex) == null)
+ return null;
+ if (e.thrower != Thread.currentThread().getId()) {
+ Class ec = ex.getClass();
+ try {
+ Constructor<?> noArgCtor = null;
+ Constructor<?>[] cs = ec.getConstructors();// public ctors only
+ for (int i = 0; i < cs.length; ++i) {
+ Constructor<?> c = cs[i];
+ Class<?>[] ps = c.getParameterTypes();
+ if (ps.length == 0)
+ noArgCtor = c;
+ else if (ps.length == 1 && ps[0] == Throwable.class)
+ return (Throwable)(c.newInstance(ex));
+ }
+ if (noArgCtor != null) {
+ Throwable wx = (Throwable)(noArgCtor.newInstance());
+ wx.initCause(ex);
+ return wx;
+ }
+ } catch (Exception ignore) {
+ }
+ }
+ return ex;
+ }
+
+ /**
+ * Poll stale refs and remove them. Call only while holding lock.
+ */
+ private static void expungeStaleExceptions() {
+ for (Object x; (x = exceptionTableRefQueue.poll()) != null;) {
+ if (x instanceof ExceptionNode) {
+ ForkJoinTask<?> key = ((ExceptionNode)x).get();
+ ExceptionNode[] t = exceptionTable;
+ int i = System.identityHashCode(key) & (t.length - 1);
+ ExceptionNode e = t[i];
+ ExceptionNode pred = null;
+ while (e != null) {
+ ExceptionNode next = e.next;
+ if (e == x) {
+ if (pred == null)
+ t[i] = next;
+ else
+ pred.next = next;
break;
}
- else if (!timed)
- wait();
- else if ((nt = nanos - (System.nanoTime()-startTime)) > 0L)
- wait(nt / 1000000, (int)(nt % 1000000));
- else
- break;
+ pred = e;
+ e = next;
}
}
}
}
/**
- * Unless done, calls exec and records status if completed, but
- * doesn't wait for completion otherwise. Primary execution method
- * for ForkJoinWorkerThread.
+ * If lock is available, poll stale refs and remove them.
+ * Called from ForkJoinPool when pools become quiescent.
*/
- final void quietlyExec() {
- try {
- if (status < 0 || !exec())
- return;
- } catch (Throwable rex) {
- setExceptionalCompletion(rex);
- return;
+ static final void helpExpungeStaleExceptions() {
+ final ReentrantLock lock = exceptionTableLock;
+ if (lock.tryLock()) {
+ try {
+ expungeStaleExceptions();
+ } finally {
+ lock.unlock();
+ }
}
- setCompletion(NORMAL); // must be outside try block
+ }
+
+ /**
+ * Report the result of invoke or join; called only upon
+ * non-normal return of internal versions.
+ */
+ private V reportResult() {
+ int s; Throwable ex;
+ if ((s = status) == CANCELLED)
+ throw new CancellationException();
+ if (s == EXCEPTIONAL && (ex = getThrowableException()) != null)
+ UNSAFE.throwException(ex);
+ return getRawResult();
}
// public methods
@@ -399,11 +636,10 @@
* @return the computed result
*/
public final V join() {
- quietlyJoin();
- Throwable ex;
- if (status < NORMAL && (ex = getException()) != null)
- UNSAFE.throwException(ex);
- return getRawResult();
+ if (doJoin() != NORMAL)
+ return reportResult();
+ else
+ return getRawResult();
}
/**
@@ -415,11 +651,10 @@
* @return the computed result
*/
public final V invoke() {
- quietlyInvoke();
- Throwable ex;
- if (status < NORMAL && (ex = getException()) != null)
- UNSAFE.throwException(ex);
- return getRawResult();
+ if (doInvoke() != NORMAL)
+ return reportResult();
+ else
+ return getRawResult();
}
/**
@@ -483,22 +718,16 @@
}
else if (i != 0)
t.fork();
- else {
- t.quietlyInvoke();
- if (ex == null && t.status < NORMAL)
- ex = t.getException();
- }
+ else if (t.doInvoke() < NORMAL && ex == null)
+ ex = t.getException();
}
for (int i = 1; i <= last; ++i) {
ForkJoinTask<?> t = tasks[i];
if (t != null) {
if (ex != null)
t.cancel(false);
- else {
- t.quietlyJoin();
- if (ex == null && t.status < NORMAL)
- ex = t.getException();
- }
+ else if (t.doJoin() < NORMAL && ex == null)
+ ex = t.getException();
}
}
if (ex != null)
@@ -546,22 +775,16 @@
}
else if (i != 0)
t.fork();
- else {
- t.quietlyInvoke();
- if (ex == null && t.status < NORMAL)
- ex = t.getException();
- }
+ else if (t.doInvoke() < NORMAL && ex == null)
+ ex = t.getException();
}
for (int i = 1; i <= last; ++i) {
ForkJoinTask<?> t = ts.get(i);
if (t != null) {
if (ex != null)
t.cancel(false);
- else {
- t.quietlyJoin();
- if (ex == null && t.status < NORMAL)
- ex = t.getException();
- }
+ else if (t.doJoin() < NORMAL && ex == null)
+ ex = t.getException();
}
}
if (ex != null)
@@ -597,8 +820,7 @@
* @return {@code true} if this task is now cancelled
*/
public boolean cancel(boolean mayInterruptIfRunning) {
- setCompletion(CANCELLED);
- return status == CANCELLED;
+ return setCompletion(CANCELLED) == CANCELLED;
}
/**
@@ -614,21 +836,6 @@
}
}
- /**
- * Cancels if current thread is a terminating worker thread,
- * ignoring any exceptions thrown by cancel.
- */
- final void cancelIfTerminating() {
- Thread t = Thread.currentThread();
- if ((t instanceof ForkJoinWorkerThread) &&
- ((ForkJoinWorkerThread) t).isTerminating()) {
- try {
- cancel(false);
- } catch (Throwable ignore) {
- }
- }
- }
-
public final boolean isDone() {
return status < 0;
}
@@ -668,7 +875,7 @@
int s = status;
return ((s >= NORMAL) ? null :
(s == CANCELLED) ? new CancellationException() :
- exceptionMap.get(this));
+ getThrowableException());
}
/**
@@ -726,19 +933,13 @@
* member of a ForkJoinPool and was interrupted while waiting
*/
public final V get() throws InterruptedException, ExecutionException {
- Thread t = Thread.currentThread();
- if (t instanceof ForkJoinWorkerThread)
- quietlyJoin();
- else
- externalInterruptibleAwaitDone(false, 0L);
- int s = status;
- if (s != NORMAL) {
- Throwable ex;
- if (s == CANCELLED)
- throw new CancellationException();
- if (s == EXCEPTIONAL && (ex = exceptionMap.get(this)) != null)
- throw new ExecutionException(ex);
- }
+ int s = (Thread.currentThread() instanceof ForkJoinWorkerThread) ?
+ doJoin() : externalInterruptibleAwaitDone(0L);
+ Throwable ex;
+ if (s == CANCELLED)
+ throw new CancellationException();
+ if (s == EXCEPTIONAL && (ex = getThrowableException()) != null)
+ throw new ExecutionException(ex);
return getRawResult();
}
@@ -758,20 +959,39 @@
*/
public final V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
- long nanos = unit.toNanos(timeout);
Thread t = Thread.currentThread();
- if (t instanceof ForkJoinWorkerThread)
- ((ForkJoinWorkerThread)t).joinTask(this, true, nanos);
- else
- externalInterruptibleAwaitDone(true, nanos);
+ if (t instanceof ForkJoinWorkerThread) {
+ ForkJoinWorkerThread w = (ForkJoinWorkerThread) t;
+ long nanos = unit.toNanos(timeout);
+ if (status >= 0) {
+ boolean completed = false;
+ if (w.unpushTask(this)) {
+ try {
+ completed = exec();
+ } catch (Throwable rex) {
+ setExceptionalCompletion(rex);
+ }
+ }
+ if (completed)
+ setCompletion(NORMAL);
+ else if (status >= 0 && nanos > 0)
+ w.pool.timedAwaitJoin(this, nanos);
+ }
+ }
+ else {
+ long millis = unit.toMillis(timeout);
+ if (millis > 0)
+ externalInterruptibleAwaitDone(millis);
+ }
int s = status;
if (s != NORMAL) {
Throwable ex;
if (s == CANCELLED)
throw new CancellationException();
- if (s == EXCEPTIONAL && (ex = exceptionMap.get(this)) != null)
+ if (s != EXCEPTIONAL)
+ throw new TimeoutException();
+ if ((ex = getThrowableException()) != null)
throw new ExecutionException(ex);
- throw new TimeoutException();
}
return getRawResult();
}
@@ -783,28 +1003,7 @@
* known to have aborted.
*/
public final void quietlyJoin() {
- Thread t;
- if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) {
- ForkJoinWorkerThread w = (ForkJoinWorkerThread) t;
- if (status >= 0) {
- if (w.unpushTask(this)) {
- boolean completed;
- try {
- completed = exec();
- } catch (Throwable rex) {
- setExceptionalCompletion(rex);
- return;
- }
- if (completed) {
- setCompletion(NORMAL);
- return;
- }
- }
- w.joinTask(this, false, 0L);
- }
- }
- else
- externalAwaitDone();
+ doJoin();
}
/**
@@ -813,19 +1012,7 @@
* exception.
*/
public final void quietlyInvoke() {
- if (status >= 0) {
- boolean completed;
- try {
- completed = exec();
- } catch (Throwable rex) {
- setExceptionalCompletion(rex);
- return;
- }
- if (completed)
- setCompletion(NORMAL);
- else
- quietlyJoin();
- }
+ doInvoke();
}
/**
@@ -864,8 +1051,9 @@
*/
public void reinitialize() {
if (status == EXCEPTIONAL)
- exceptionMap.remove(this);
- status = 0;
+ clearExceptionalCompletion();
+ else
+ status = 0;
}
/**
@@ -1176,23 +1364,23 @@
s.defaultReadObject();
Object ex = s.readObject();
if (ex != null)
- setExceptionalCompletion((Throwable) ex);
+ setExceptionalCompletion((Throwable)ex);
}
// Unsafe mechanics
-
- private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
- private static final long statusOffset =
- objectFieldOffset("status", ForkJoinTask.class);
-
- private static long objectFieldOffset(String field, Class<?> klazz) {
+ private static final sun.misc.Unsafe UNSAFE;
+ private static final long statusOffset;
+ static {
+ exceptionTableLock = new ReentrantLock();
+ exceptionTableRefQueue = new ReferenceQueue<Object>();
+ exceptionTable = new ExceptionNode[EXCEPTION_MAP_CAPACITY];
try {
- return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
- } catch (NoSuchFieldException e) {
- // Convert Exception to corresponding Error
- NoSuchFieldError error = new NoSuchFieldError(field);
- error.initCause(e);
- throw error;
+ UNSAFE = sun.misc.Unsafe.getUnsafe();
+ statusOffset = UNSAFE.objectFieldOffset
+ (ForkJoinTask.class.getDeclaredField("status"));
+ } catch (Exception e) {
+ throw new Error(e);
}
}
+
}
--- a/jdk/src/share/classes/java/util/concurrent/ForkJoinWorkerThread.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/java/util/concurrent/ForkJoinWorkerThread.java Mon Mar 21 16:57:18 2011 -0700
@@ -35,9 +35,7 @@
package java.util.concurrent;
-import java.util.Random;
import java.util.Collection;
-import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.RejectedExecutionException;
/**
@@ -84,33 +82,38 @@
* a footprint as possible even in programs generating huge
* numbers of tasks. To accomplish this, we shift the CAS
* arbitrating pop vs deq (steal) from being on the indices
- * ("base" and "sp") to the slots themselves (mainly via method
- * "casSlotNull()"). So, both a successful pop and deq mainly
- * entail a CAS of a slot from non-null to null. Because we rely
- * on CASes of references, we do not need tag bits on base or sp.
- * They are simple ints as used in any circular array-based queue
- * (see for example ArrayDeque). Updates to the indices must
- * still be ordered in a way that guarantees that sp == base means
- * the queue is empty, but otherwise may err on the side of
- * possibly making the queue appear nonempty when a push, pop, or
- * deq have not fully committed. Note that this means that the deq
- * operation, considered individually, is not wait-free. One thief
- * cannot successfully continue until another in-progress one (or,
- * if previously empty, a push) completes. However, in the
+ * ("queueBase" and "queueTop") to the slots themselves (mainly
+ * via method "casSlotNull()"). So, both a successful pop and deq
+ * mainly entail a CAS of a slot from non-null to null. Because
+ * we rely on CASes of references, we do not need tag bits on
+ * queueBase or queueTop. They are simple ints as used in any
+ * circular array-based queue (see for example ArrayDeque).
+ * Updates to the indices must still be ordered in a way that
+ * guarantees that queueTop == queueBase means the queue is empty,
+ * but otherwise may err on the side of possibly making the queue
+ * appear nonempty when a push, pop, or deq have not fully
+ * committed. Note that this means that the deq operation,
+ * considered individually, is not wait-free. One thief cannot
+ * successfully continue until another in-progress one (or, if
+ * previously empty, a push) completes. However, in the
* aggregate, we ensure at least probabilistic non-blockingness.
* If an attempted steal fails, a thief always chooses a different
* random victim target to try next. So, in order for one thief to
* progress, it suffices for any in-progress deq or new push on
- * any empty queue to complete. One reason this works well here is
- * that apparently-nonempty often means soon-to-be-stealable,
- * which gives threads a chance to set activation status if
- * necessary before stealing.
+ * any empty queue to complete.
*
* This approach also enables support for "async mode" where local
* task processing is in FIFO, not LIFO order; simply by using a
* version of deq rather than pop when locallyFifo is true (as set
* by the ForkJoinPool). This allows use in message-passing
- * frameworks in which tasks are never joined.
+ * frameworks in which tasks are never joined. However neither
+ * mode considers affinities, loads, cache localities, etc, so
+ * rarely provide the best possible performance on a given
+ * machine, but portably provide good throughput by averaging over
+ * these factors. (Further, even if we did try to use such
+ * information, we do not usually have a basis for exploiting
+ * it. For example, some sets of tasks profit from cache
+ * affinities, but others are harmed by cache pollution effects.)
*
* When a worker would otherwise be blocked waiting to join a
* task, it first tries a form of linear helping: Each worker
@@ -137,29 +140,26 @@
* miss links in the chain during long-lived tasks, GC stalls etc
* (which is OK since blocking in such cases is usually a good
* idea). (4) We bound the number of attempts to find work (see
- * MAX_HELP_DEPTH) and fall back to suspending the worker and if
- * necessary replacing it with a spare (see
- * ForkJoinPool.awaitJoin).
+ * MAX_HELP) and fall back to suspending the worker and if
+ * necessary replacing it with another.
*
* Efficient implementation of these algorithms currently relies
* on an uncomfortable amount of "Unsafe" mechanics. To maintain
- * correct orderings, reads and writes of variable base require
- * volatile ordering. Variable sp does not require volatile
- * writes but still needs store-ordering, which we accomplish by
- * pre-incrementing sp before filling the slot with an ordered
- * store. (Pre-incrementing also enables backouts used in
- * joinTask.) Because they are protected by volatile base reads,
- * reads of the queue array and its slots by other threads do not
- * need volatile load semantics, but writes (in push) require
- * store order and CASes (in pop and deq) require (volatile) CAS
- * semantics. (Michael, Saraswat, and Vechev's algorithm has
- * similar properties, but without support for nulling slots.)
- * Since these combinations aren't supported using ordinary
- * volatiles, the only way to accomplish these efficiently is to
- * use direct Unsafe calls. (Using external AtomicIntegers and
- * AtomicReferenceArrays for the indices and array is
- * significantly slower because of memory locality and indirection
- * effects.)
+ * correct orderings, reads and writes of variable queueBase
+ * require volatile ordering. Variable queueTop need not be
+ * volatile because non-local reads always follow those of
+ * queueBase. Similarly, because they are protected by volatile
+ * queueBase reads, reads of the queue array and its slots by
+ * other threads do not need volatile load semantics, but writes
+ * (in push) require store order and CASes (in pop and deq)
+ * require (volatile) CAS semantics. (Michael, Saraswat, and
+ * Vechev's algorithm has similar properties, but without support
+ * for nulling slots.) Since these combinations aren't supported
+ * using ordinary volatiles, the only way to accomplish these
+ * efficiently is to use direct Unsafe calls. (Using external
+ * AtomicIntegers and AtomicReferenceArrays for the indices and
+ * array is significantly slower because of memory locality and
+ * indirection effects.)
*
* Further, performance on most platforms is very sensitive to
* placement and sizing of the (resizable) queue array. Even
@@ -167,30 +167,13 @@
* initial size must be large enough to counteract cache
* contention effects across multiple queues (especially in the
* presence of GC cardmarking). Also, to improve thread-locality,
- * queues are initialized after starting. All together, these
- * low-level implementation choices produce as much as a factor of
- * 4 performance improvement compared to naive implementations,
- * and enable the processing of billions of tasks per second,
- * sometimes at the expense of ugliness.
+ * queues are initialized after starting.
*/
/**
- * Generator for initial random seeds for random victim
- * selection. This is used only to create initial seeds. Random
- * steals use a cheaper xorshift generator per steal attempt. We
- * expect only rare contention on seedGenerator, so just use a
- * plain Random.
+ * Mask for pool indices encoded as shorts
*/
- private static final Random seedGenerator = new Random();
-
- /**
- * The maximum stolen->joining link depth allowed in helpJoinTask.
- * Depths for legitimate chains are unbounded, but we use a fixed
- * constant to avoid (otherwise unchecked) cycles and bound
- * staleness of traversal parameters at the expense of sometimes
- * blocking when we could be helping.
- */
- private static final int MAX_HELP_DEPTH = 8;
+ private static final int SMASK = 0xffff;
/**
* Capacity of work-stealing queue array upon initialization.
@@ -200,12 +183,19 @@
private static final int INITIAL_QUEUE_CAPACITY = 1 << 13;
/**
- * Maximum work-stealing queue array size. Must be less than or
- * equal to 1 << (31 - width of array entry) to ensure lack of
- * index wraparound. The value is set in the static block
- * at the end of this file after obtaining width.
+ * Maximum size for queue array. Must be a power of two
+ * less than or equal to 1 << (31 - width of array entry) to
+ * ensure lack of index wraparound, but is capped at a lower
+ * value to help users trap runaway computations.
*/
- private static final int MAXIMUM_QUEUE_CAPACITY;
+ private static final int MAXIMUM_QUEUE_CAPACITY = 1 << 24; // 16M
+
+ /**
+ * The work-stealing queue array. Size must be a power of two.
+ * Initialized when started (as oposed to when constructed), to
+ * improve memory locality.
+ */
+ ForkJoinTask<?>[] queue;
/**
* The pool this thread works in. Accessed directly by ForkJoinTask.
@@ -213,25 +203,19 @@
final ForkJoinPool pool;
/**
- * The work-stealing queue array. Size must be a power of two.
- * Initialized in onStart, to improve memory locality.
+ * Index (mod queue.length) of next queue slot to push to or pop
+ * from. It is written only by owner thread, and accessed by other
+ * threads only after reading (volatile) queueBase. Both queueTop
+ * and queueBase are allowed to wrap around on overflow, but
+ * (queueTop - queueBase) still estimates size.
*/
- private ForkJoinTask<?>[] queue;
+ int queueTop;
/**
* Index (mod queue.length) of least valid queue slot, which is
* always the next position to steal from if nonempty.
*/
- private volatile int base;
-
- /**
- * Index (mod queue.length) of next queue slot to push to or pop
- * from. It is written only by owner thread, and accessed by other
- * threads only after reading (volatile) base. Both sp and base
- * are allowed to wrap around on overflow, but (sp - base) still
- * estimates size.
- */
- private int sp;
+ volatile int queueBase;
/**
* The index of most recent stealer, used as a hint to avoid
@@ -240,92 +224,68 @@
* of them (usually the most current). Declared non-volatile,
* relying on other prevailing sync to keep reasonably current.
*/
- private int stealHint;
-
- /**
- * Run state of this worker. In addition to the usual run levels,
- * tracks if this worker is suspended as a spare, and if it was
- * killed (trimmed) while suspended. However, "active" status is
- * maintained separately and modified only in conjunction with
- * CASes of the pool's runState (which are currently sadly
- * manually inlined for performance.) Accessed directly by pool
- * to simplify checks for normal (zero) status.
- */
- volatile int runState;
-
- private static final int TERMINATING = 0x01;
- private static final int TERMINATED = 0x02;
- private static final int SUSPENDED = 0x04; // inactive spare
- private static final int TRIMMED = 0x08; // killed while suspended
-
- /**
- * Number of steals. Directly accessed (and reset) by
- * pool.tryAccumulateStealCount when idle.
- */
- int stealCount;
-
- /**
- * Seed for random number generator for choosing steal victims.
- * Uses Marsaglia xorshift. Must be initialized as nonzero.
- */
- private int seed;
-
- /**
- * Activity status. When true, this worker is considered active.
- * Accessed directly by pool. Must be false upon construction.
- */
- boolean active;
-
- /**
- * True if use local fifo, not default lifo, for local polling.
- * Shadows value from ForkJoinPool.
- */
- private final boolean locallyFifo;
+ int stealHint;
/**
* Index of this worker in pool array. Set once by pool before
* running, and accessed directly by pool to locate this worker in
* its workers array.
*/
- int poolIndex;
+ final int poolIndex;
+
+ /**
+ * Encoded record for pool task waits. Usages are always
+ * surrounded by volatile reads/writes
+ */
+ int nextWait;
/**
- * The last pool event waited for. Accessed only by pool in
- * callback methods invoked within this thread.
+ * Complement of poolIndex, offset by count of entries of task
+ * waits. Accessed by ForkJoinPool to manage event waiters.
*/
- int lastEventCount;
+ volatile int eventCount;
+
+ /**
+ * Seed for random number generator for choosing steal victims.
+ * Uses Marsaglia xorshift. Must be initialized as nonzero.
+ */
+ int seed;
/**
- * Encoded index and event count of next event waiter. Accessed
- * only by ForkJoinPool for managing event waiters.
+ * Number of steals. Directly accessed (and reset) by pool when
+ * idle.
*/
- volatile long nextWaiter;
+ int stealCount;
+
+ /**
+ * True if this worker should or did terminate
+ */
+ volatile boolean terminate;
/**
- * Number of times this thread suspended as spare. Accessed only
- * by pool.
+ * Set to true before LockSupport.park; false on return
*/
- int spareCount;
+ volatile boolean parked;
/**
- * Encoded index and count of next spare waiter. Accessed only
- * by ForkJoinPool for managing spares.
+ * True if use local fifo, not default lifo, for local polling.
+ * Shadows value from ForkJoinPool.
*/
- volatile int nextSpare;
+ final boolean locallyFifo;
+
+ /**
+ * The task most recently stolen from another worker (or
+ * submission queue). All uses are surrounded by enough volatile
+ * reads/writes to maintain as non-volatile.
+ */
+ ForkJoinTask<?> currentSteal;
/**
* The task currently being joined, set only when actively trying
- * to help other stealers in helpJoinTask. Written only by this
- * thread, but read by others.
+ * to help other stealers in helpJoinTask. All uses are surrounded
+ * by enough volatile reads/writes to maintain as non-volatile.
*/
- private volatile ForkJoinTask<?> currentJoin;
-
- /**
- * The task most recently stolen from another worker (or
- * submission queue). Written only by this thread, but read by
- * others.
- */
- private volatile ForkJoinTask<?> currentSteal;
+ ForkJoinTask<?> currentJoin;
/**
* Creates a ForkJoinWorkerThread operating in the given pool.
@@ -334,24 +294,19 @@
* @throws NullPointerException if pool is null
*/
protected ForkJoinWorkerThread(ForkJoinPool pool) {
+ super(pool.nextWorkerName());
this.pool = pool;
- this.locallyFifo = pool.locallyFifo;
+ int k = pool.registerWorker(this);
+ poolIndex = k;
+ eventCount = ~k & SMASK; // clear wait count
+ locallyFifo = pool.locallyFifo;
+ Thread.UncaughtExceptionHandler ueh = pool.ueh;
+ if (ueh != null)
+ setUncaughtExceptionHandler(ueh);
setDaemon(true);
- // To avoid exposing construction details to subclasses,
- // remaining initialization is in start() and onStart()
}
- /**
- * Performs additional initialization and starts this thread.
- */
- final void start(int poolIndex, UncaughtExceptionHandler ueh) {
- this.poolIndex = poolIndex;
- if (ueh != null)
- setUncaughtExceptionHandler(ueh);
- start();
- }
-
- // Public/protected methods
+ // Public methods
/**
* Returns the pool hosting this thread.
@@ -375,6 +330,25 @@
return poolIndex;
}
+ // Randomization
+
+ /**
+ * Computes next value for random victim probes and backoffs.
+ * Scans don't require a very high quality generator, but also not
+ * a crummy one. Marsaglia xor-shift is cheap and works well
+ * enough. Note: This is manually inlined in FJP.scan() to avoid
+ * writes inside busy loops.
+ */
+ private int nextSeed() {
+ int r = seed;
+ r ^= r << 13;
+ r ^= r >>> 17;
+ r ^= r << 5;
+ return seed = r;
+ }
+
+ // Run State management
+
/**
* Initializes internal state after construction but before
* processing any tasks. If you override this method, you must
@@ -385,15 +359,9 @@
* processing tasks.
*/
protected void onStart() {
- int rs = seedGenerator.nextInt();
- seed = (rs == 0) ? 1 : rs; // seed must be nonzero
-
- // Allocate name string and arrays in this thread
- String pid = Integer.toString(pool.getPoolNumber());
- String wid = Integer.toString(poolIndex);
- setName("ForkJoinPool-" + pid + "-worker-" + wid);
-
queue = new ForkJoinTask<?>[INITIAL_QUEUE_CAPACITY];
+ int r = pool.workerSeedGenerator.nextInt();
+ seed = (r == 0)? 1 : r; // must be nonzero
}
/**
@@ -406,16 +374,9 @@
*/
protected void onTermination(Throwable exception) {
try {
- ForkJoinPool p = pool;
- if (active) {
- int a; // inline p.tryDecrementActiveCount
- active = false;
- do {} while (!UNSAFE.compareAndSwapInt
- (p, poolRunStateOffset, a = p.runState, a - 1));
- }
+ terminate = true;
cancelTasks();
- setTerminated();
- p.workerTerminated(this);
+ pool.deregisterWorker(this, exception);
} catch (Throwable ex) { // Shouldn't ever happen
if (exception == null) // but if so, at least rethrown
exception = ex;
@@ -434,7 +395,7 @@
Throwable exception = null;
try {
onStart();
- mainLoop();
+ pool.work(this);
} catch (Throwable ex) {
exception = ex;
} finally {
@@ -442,81 +403,6 @@
}
}
- // helpers for run()
-
- /**
- * Finds and executes tasks, and checks status while running.
- */
- private void mainLoop() {
- boolean ran = false; // true if ran a task on last step
- ForkJoinPool p = pool;
- for (;;) {
- p.preStep(this, ran);
- if (runState != 0)
- break;
- ran = tryExecSteal() || tryExecSubmission();
- }
- }
-
- /**
- * Tries to steal a task and execute it.
- *
- * @return true if ran a task
- */
- private boolean tryExecSteal() {
- ForkJoinTask<?> t;
- if ((t = scan()) != null) {
- t.quietlyExec();
- UNSAFE.putOrderedObject(this, currentStealOffset, null);
- if (sp != base)
- execLocalTasks();
- return true;
- }
- return false;
- }
-
- /**
- * If a submission exists, try to activate and run it.
- *
- * @return true if ran a task
- */
- private boolean tryExecSubmission() {
- ForkJoinPool p = pool;
- // This loop is needed in case attempt to activate fails, in
- // which case we only retry if there still appears to be a
- // submission.
- while (p.hasQueuedSubmissions()) {
- ForkJoinTask<?> t; int a;
- if (active || // inline p.tryIncrementActiveCount
- (active = UNSAFE.compareAndSwapInt(p, poolRunStateOffset,
- a = p.runState, a + 1))) {
- if ((t = p.pollSubmission()) != null) {
- UNSAFE.putOrderedObject(this, currentStealOffset, t);
- t.quietlyExec();
- UNSAFE.putOrderedObject(this, currentStealOffset, null);
- if (sp != base)
- execLocalTasks();
- return true;
- }
- }
- }
- return false;
- }
-
- /**
- * Runs local tasks until queue is empty or shut down. Call only
- * while active.
- */
- private void execLocalTasks() {
- while (runState == 0) {
- ForkJoinTask<?> t = locallyFifo ? locallyDeqTask() : popTask();
- if (t != null)
- t.quietlyExec();
- else if (sp == base)
- break;
- }
- }
-
/*
* Intrinsics-based atomic writes for queue slots. These are
* basically the same as methods in AtomicReferenceArray, but
@@ -528,10 +414,20 @@
* because they are protected by other volatile reads and are
* confirmed by CASes.
*
- * Most uses don't actually call these methods, but instead contain
- * inlined forms that enable more predictable optimization. We
- * don't define the version of write used in pushTask at all, but
- * instead inline there a store-fenced array slot write.
+ * Most uses don't actually call these methods, but instead
+ * contain inlined forms that enable more predictable
+ * optimization. We don't define the version of write used in
+ * pushTask at all, but instead inline there a store-fenced array
+ * slot write.
+ *
+ * Also in most methods, as a performance (not correctness) issue,
+ * we'd like to encourage compilers not to arbitrarily postpone
+ * setting queueTop after writing slot. Currently there is no
+ * intrinsic for arranging this, but using Unsafe putOrderedInt
+ * may be a preferable strategy on some compilers even though its
+ * main effect is a pre-, not post- fence. To simplify possible
+ * changes, the option is left in comments next to the associated
+ * assignments.
*/
/**
@@ -540,7 +436,7 @@
*/
private static final boolean casSlotNull(ForkJoinTask<?>[] q, int i,
ForkJoinTask<?> t) {
- return UNSAFE.compareAndSwapObject(q, (i << qShift) + qBase, t, null);
+ return UNSAFE.compareAndSwapObject(q, (i << ASHIFT) + ABASE, t, null);
}
/**
@@ -550,7 +446,7 @@
*/
private static final void writeSlot(ForkJoinTask<?>[] q, int i,
ForkJoinTask<?> t) {
- UNSAFE.putObjectVolatile(q, (i << qShift) + qBase, t);
+ UNSAFE.putObjectVolatile(q, (i << ASHIFT) + ABASE, t);
}
// queue methods
@@ -561,14 +457,43 @@
* @param t the task. Caller must ensure non-null.
*/
final void pushTask(ForkJoinTask<?> t) {
- ForkJoinTask<?>[] q = queue;
- int mask = q.length - 1; // implicit assert q != null
- int s = sp++; // ok to increment sp before slot write
- UNSAFE.putOrderedObject(q, ((s & mask) << qShift) + qBase, t);
- if ((s -= base) == 0)
- pool.signalWork(); // was empty
- else if (s == mask)
- growQueue(); // is full
+ ForkJoinTask<?>[] q; int s, m;
+ if ((q = queue) != null) { // ignore if queue removed
+ long u = (((s = queueTop) & (m = q.length - 1)) << ASHIFT) + ABASE;
+ UNSAFE.putOrderedObject(q, u, t);
+ queueTop = s + 1; // or use putOrderedInt
+ if ((s -= queueBase) <= 2)
+ pool.signalWork();
+ else if (s == m)
+ growQueue();
+ }
+ }
+
+ /**
+ * Creates or doubles queue array. Transfers elements by
+ * emulating steals (deqs) from old array and placing, oldest
+ * first, into new array.
+ */
+ private void growQueue() {
+ ForkJoinTask<?>[] oldQ = queue;
+ int size = oldQ != null ? oldQ.length << 1 : INITIAL_QUEUE_CAPACITY;
+ if (size > MAXIMUM_QUEUE_CAPACITY)
+ throw new RejectedExecutionException("Queue capacity exceeded");
+ if (size < INITIAL_QUEUE_CAPACITY)
+ size = INITIAL_QUEUE_CAPACITY;
+ ForkJoinTask<?>[] q = queue = new ForkJoinTask<?>[size];
+ int mask = size - 1;
+ int top = queueTop;
+ int oldMask;
+ if (oldQ != null && (oldMask = oldQ.length - 1) >= 0) {
+ for (int b = queueBase; b != top; ++b) {
+ long u = ((b & oldMask) << ASHIFT) + ABASE;
+ Object x = UNSAFE.getObjectVolatile(oldQ, u);
+ if (x != null && UNSAFE.compareAndSwapObject(oldQ, u, x, null))
+ UNSAFE.putObjectVolatile
+ (q, ((b & mask) << ASHIFT) + ABASE, x);
+ }
+ }
}
/**
@@ -579,35 +504,34 @@
* @return a task, or null if none or contended
*/
final ForkJoinTask<?> deqTask() {
- ForkJoinTask<?> t;
- ForkJoinTask<?>[] q;
- int b, i;
- if (sp != (b = base) &&
+ ForkJoinTask<?> t; ForkJoinTask<?>[] q; int b, i;
+ if (queueTop != (b = queueBase) &&
(q = queue) != null && // must read q after b
- (t = q[i = (q.length - 1) & b]) != null && base == b &&
- UNSAFE.compareAndSwapObject(q, (i << qShift) + qBase, t, null)) {
- base = b + 1;
+ (i = (q.length - 1) & b) >= 0 &&
+ (t = q[i]) != null && queueBase == b &&
+ UNSAFE.compareAndSwapObject(q, (i << ASHIFT) + ABASE, t, null)) {
+ queueBase = b + 1;
return t;
}
return null;
}
/**
- * Tries to take a task from the base of own queue. Assumes active
- * status. Called only by this thread.
+ * Tries to take a task from the base of own queue. Called only
+ * by this thread.
*
* @return a task, or null if none
*/
final ForkJoinTask<?> locallyDeqTask() {
+ ForkJoinTask<?> t; int m, b, i;
ForkJoinTask<?>[] q = queue;
- if (q != null) {
- ForkJoinTask<?> t;
- int b, i;
- while (sp != (b = base)) {
- if ((t = q[i = (q.length - 1) & b]) != null && base == b &&
- UNSAFE.compareAndSwapObject(q, (i << qShift) + qBase,
+ if (q != null && (m = q.length - 1) >= 0) {
+ while (queueTop != (b = queueBase)) {
+ if ((t = q[i = m & b]) != null &&
+ queueBase == b &&
+ UNSAFE.compareAndSwapObject(q, (i << ASHIFT) + ABASE,
t, null)) {
- base = b + 1;
+ queueBase = b + 1;
return t;
}
}
@@ -616,35 +540,21 @@
}
/**
- * Returns a popped task, or null if empty. Assumes active status.
+ * Returns a popped task, or null if empty.
* Called only by this thread.
*/
private ForkJoinTask<?> popTask() {
+ int m;
ForkJoinTask<?>[] q = queue;
- if (q != null) {
- int s;
- while ((s = sp) != base) {
- int i = (q.length - 1) & --s;
- long u = (i << qShift) + qBase; // raw offset
+ if (q != null && (m = q.length - 1) >= 0) {
+ for (int s; (s = queueTop) != queueBase;) {
+ int i = m & --s;
+ long u = (i << ASHIFT) + ABASE; // raw offset
ForkJoinTask<?> t = q[i];
if (t == null) // lost to stealer
break;
if (UNSAFE.compareAndSwapObject(q, u, t, null)) {
- /*
- * Note: here and in related methods, as a
- * performance (not correctness) issue, we'd like
- * to encourage compiler not to arbitrarily
- * postpone setting sp after successful CAS.
- * Currently there is no intrinsic for arranging
- * this, but using Unsafe putOrderedInt may be a
- * preferable strategy on some compilers even
- * though its main effect is a pre-, not post-
- * fence. To simplify possible changes, the option
- * is left in comments next to the associated
- * assignments.
- */
- sp = s; // putOrderedInt may encourage more timely write
- // UNSAFE.putOrderedInt(this, spOffset, s);
+ queueTop = s; // or putOrderedInt
return t;
}
}
@@ -654,18 +564,17 @@
/**
* Specialized version of popTask to pop only if topmost element
- * is the given task. Called only by this thread while active.
+ * is the given task. Called only by this thread.
*
* @param t the task. Caller must ensure non-null.
*/
final boolean unpushTask(ForkJoinTask<?> t) {
+ ForkJoinTask<?>[] q;
int s;
- ForkJoinTask<?>[] q = queue;
- if ((s = sp) != base && q != null &&
+ if ((q = queue) != null && (s = queueTop) != queueBase &&
UNSAFE.compareAndSwapObject
- (q, (((q.length - 1) & --s) << qShift) + qBase, t, null)) {
- sp = s; // putOrderedInt may encourage more timely write
- // UNSAFE.putOrderedInt(this, spOffset, s);
+ (q, (((q.length - 1) & --s) << ASHIFT) + ABASE, t, null)) {
+ queueTop = s; // or putOrderedInt
return true;
}
return false;
@@ -675,222 +584,30 @@
* Returns next task, or null if empty or contended.
*/
final ForkJoinTask<?> peekTask() {
+ int m;
ForkJoinTask<?>[] q = queue;
- if (q == null)
+ if (q == null || (m = q.length - 1) < 0)
return null;
- int mask = q.length - 1;
- int i = locallyFifo ? base : (sp - 1);
- return q[i & mask];
+ int i = locallyFifo ? queueBase : (queueTop - 1);
+ return q[i & m];
}
- /**
- * Doubles queue array size. Transfers elements by emulating
- * steals (deqs) from old array and placing, oldest first, into
- * new array.
- */
- private void growQueue() {
- ForkJoinTask<?>[] oldQ = queue;
- int oldSize = oldQ.length;
- int newSize = oldSize << 1;
- if (newSize > MAXIMUM_QUEUE_CAPACITY)
- throw new RejectedExecutionException("Queue capacity exceeded");
- ForkJoinTask<?>[] newQ = queue = new ForkJoinTask<?>[newSize];
-
- int b = base;
- int bf = b + oldSize;
- int oldMask = oldSize - 1;
- int newMask = newSize - 1;
- do {
- int oldIndex = b & oldMask;
- ForkJoinTask<?> t = oldQ[oldIndex];
- if (t != null && !casSlotNull(oldQ, oldIndex, t))
- t = null;
- writeSlot(newQ, b & newMask, t);
- } while (++b != bf);
- pool.signalWork();
- }
-
- /**
- * Computes next value for random victim probe in scan(). Scans
- * don't require a very high quality generator, but also not a
- * crummy one. Marsaglia xor-shift is cheap and works well enough.
- * Note: This is manually inlined in scan().
- */
- private static final int xorShift(int r) {
- r ^= r << 13;
- r ^= r >>> 17;
- return r ^ (r << 5);
- }
+ // Support methods for ForkJoinPool
/**
- * Tries to steal a task from another worker. Starts at a random
- * index of workers array, and probes workers until finding one
- * with non-empty queue or finding that all are empty. It
- * randomly selects the first n probes. If these are empty, it
- * resorts to a circular sweep, which is necessary to accurately
- * set active status. (The circular sweep uses steps of
- * approximately half the array size plus 1, to avoid bias
- * stemming from leftmost packing of the array in ForkJoinPool.)
- *
- * This method must be both fast and quiet -- usually avoiding
- * memory accesses that could disrupt cache sharing etc other than
- * those needed to check for and take tasks (or to activate if not
- * already active). This accounts for, among other things,
- * updating random seed in place without storing it until exit.
- *
- * @return a task, or null if none found
+ * Runs the given task, plus any local tasks until queue is empty
*/
- private ForkJoinTask<?> scan() {
- ForkJoinPool p = pool;
- ForkJoinWorkerThread[] ws; // worker array
- int n; // upper bound of #workers
- if ((ws = p.workers) != null && (n = ws.length) > 1) {
- boolean canSteal = active; // shadow active status
- int r = seed; // extract seed once
- int mask = n - 1;
- int j = -n; // loop counter
- int k = r; // worker index, random if j < 0
- for (;;) {
- ForkJoinWorkerThread v = ws[k & mask];
- r ^= r << 13; r ^= r >>> 17; r ^= r << 5; // inline xorshift
- ForkJoinTask<?>[] q; ForkJoinTask<?> t; int b, a;
- if (v != null && (b = v.base) != v.sp &&
- (q = v.queue) != null) {
- int i = (q.length - 1) & b;
- long u = (i << qShift) + qBase; // raw offset
- int pid = poolIndex;
- if ((t = q[i]) != null) {
- if (!canSteal && // inline p.tryIncrementActiveCount
- UNSAFE.compareAndSwapInt(p, poolRunStateOffset,
- a = p.runState, a + 1))
- canSteal = active = true;
- if (canSteal && v.base == b++ &&
- UNSAFE.compareAndSwapObject(q, u, t, null)) {
- v.base = b;
- v.stealHint = pid;
- UNSAFE.putOrderedObject(this,
- currentStealOffset, t);
- seed = r;
- ++stealCount;
- return t;
- }
- }
- j = -n;
- k = r; // restart on contention
- }
- else if (++j <= 0)
- k = r;
- else if (j <= n)
- k += (n >>> 1) | 1;
- else
- break;
- }
- }
- return null;
- }
-
- // Run State management
-
- // status check methods used mainly by ForkJoinPool
- final boolean isRunning() { return runState == 0; }
- final boolean isTerminated() { return (runState & TERMINATED) != 0; }
- final boolean isSuspended() { return (runState & SUSPENDED) != 0; }
- final boolean isTrimmed() { return (runState & TRIMMED) != 0; }
-
- final boolean isTerminating() {
- if ((runState & TERMINATING) != 0)
- return true;
- if (pool.isAtLeastTerminating()) { // propagate pool state
- shutdown();
- return true;
+ final void execTask(ForkJoinTask<?> t) {
+ currentSteal = t;
+ for (;;) {
+ if (t != null)
+ t.doExec();
+ if (queueTop == queueBase)
+ break;
+ t = locallyFifo ? locallyDeqTask() : popTask();
}
- return false;
- }
-
- /**
- * Sets state to TERMINATING. Does NOT unpark or interrupt
- * to wake up if currently blocked. Callers must do so if desired.
- */
- final void shutdown() {
- for (;;) {
- int s = runState;
- if ((s & (TERMINATING|TERMINATED)) != 0)
- break;
- if ((s & SUSPENDED) != 0) { // kill and wakeup if suspended
- if (UNSAFE.compareAndSwapInt(this, runStateOffset, s,
- (s & ~SUSPENDED) |
- (TRIMMED|TERMINATING)))
- break;
- }
- else if (UNSAFE.compareAndSwapInt(this, runStateOffset, s,
- s | TERMINATING))
- break;
- }
- }
-
- /**
- * Sets state to TERMINATED. Called only by onTermination().
- */
- private void setTerminated() {
- int s;
- do {} while (!UNSAFE.compareAndSwapInt(this, runStateOffset,
- s = runState,
- s | (TERMINATING|TERMINATED)));
- }
-
- /**
- * If suspended, tries to set status to unsuspended.
- * Does NOT wake up if blocked.
- *
- * @return true if successful
- */
- final boolean tryUnsuspend() {
- int s;
- while (((s = runState) & SUSPENDED) != 0) {
- if (UNSAFE.compareAndSwapInt(this, runStateOffset, s,
- s & ~SUSPENDED))
- return true;
- }
- return false;
- }
-
- /**
- * Sets suspended status and blocks as spare until resumed
- * or shutdown.
- */
- final void suspendAsSpare() {
- for (;;) { // set suspended unless terminating
- int s = runState;
- if ((s & TERMINATING) != 0) { // must kill
- if (UNSAFE.compareAndSwapInt(this, runStateOffset, s,
- s | (TRIMMED | TERMINATING)))
- return;
- }
- else if (UNSAFE.compareAndSwapInt(this, runStateOffset, s,
- s | SUSPENDED))
- break;
- }
- ForkJoinPool p = pool;
- p.pushSpare(this);
- while ((runState & SUSPENDED) != 0) {
- if (p.tryAccumulateStealCount(this)) {
- interrupted(); // clear/ignore interrupts
- if ((runState & SUSPENDED) == 0)
- break;
- LockSupport.park(this);
- }
- }
- }
-
- // Misc support methods for ForkJoinPool
-
- /**
- * Returns an estimate of the number of tasks in the queue. Also
- * used by ForkJoinTask.
- */
- final int getQueueSize() {
- int n; // external calls must read base first
- return (n = -base + sp) <= 0 ? 0 : n;
+ ++stealCount;
+ currentSteal = null;
}
/**
@@ -899,17 +616,12 @@
*/
final void cancelTasks() {
ForkJoinTask<?> cj = currentJoin; // try to cancel ongoing tasks
- if (cj != null && cj.status >= 0) {
+ if (cj != null && cj.status >= 0)
cj.cancelIgnoringExceptions();
- try {
- this.interrupt(); // awaken wait
- } catch (SecurityException ignore) {
- }
- }
ForkJoinTask<?> cs = currentSteal;
if (cs != null && cs.status >= 0)
cs.cancelIgnoringExceptions();
- while (base != sp) {
+ while (queueBase != queueTop) {
ForkJoinTask<?> t = deqTask();
if (t != null)
t.cancelIgnoringExceptions();
@@ -923,7 +635,7 @@
*/
final int drainTasksTo(Collection<? super ForkJoinTask<?>> c) {
int n = 0;
- while (base != sp) {
+ while (queueBase != queueTop) {
ForkJoinTask<?> t = deqTask();
if (t != null) {
c.add(t);
@@ -936,20 +648,19 @@
// Support methods for ForkJoinTask
/**
+ * Returns an estimate of the number of tasks in the queue.
+ */
+ final int getQueueSize() {
+ return queueTop - queueBase;
+ }
+
+ /**
* Gets and removes a local task.
*
* @return a task, if available
*/
final ForkJoinTask<?> pollLocalTask() {
- ForkJoinPool p = pool;
- while (sp != base) {
- int a; // inline p.tryIncrementActiveCount
- if (active ||
- (active = UNSAFE.compareAndSwapInt(p, poolRunStateOffset,
- a = p.runState, a + 1)))
- return locallyFifo ? locallyDeqTask() : popTask();
- }
- return null;
+ return locallyFifo ? locallyDeqTask() : popTask();
}
/**
@@ -958,172 +669,205 @@
* @return a task, if available
*/
final ForkJoinTask<?> pollTask() {
+ ForkJoinWorkerThread[] ws;
ForkJoinTask<?> t = pollLocalTask();
- if (t == null) {
- t = scan();
- // cannot retain/track/help steal
- UNSAFE.putOrderedObject(this, currentStealOffset, null);
+ if (t != null || (ws = pool.workers) == null)
+ return t;
+ int n = ws.length; // cheap version of FJP.scan
+ int steps = n << 1;
+ int r = nextSeed();
+ int i = 0;
+ while (i < steps) {
+ ForkJoinWorkerThread w = ws[(i++ + r) & (n - 1)];
+ if (w != null && w.queueBase != w.queueTop && w.queue != null) {
+ if ((t = w.deqTask()) != null)
+ return t;
+ i = 0;
+ }
}
- return t;
+ return null;
}
/**
- * Possibly runs some tasks and/or blocks, until task is done.
+ * The maximum stolen->joining link depth allowed in helpJoinTask,
+ * as well as the maximum number of retries (allowing on average
+ * one staleness retry per level) per attempt to instead try
+ * compensation. Depths for legitimate chains are unbounded, but
+ * we use a fixed constant to avoid (otherwise unchecked) cycles
+ * and bound staleness of traversal parameters at the expense of
+ * sometimes blocking when we could be helping.
+ */
+ private static final int MAX_HELP = 16;
+
+ /**
+ * Possibly runs some tasks and/or blocks, until joinMe is done.
*
* @param joinMe the task to join
- * @param timed true if use timed wait
- * @param nanos wait time if timed
+ * @return completion status on exit
*/
- final void joinTask(ForkJoinTask<?> joinMe, boolean timed, long nanos) {
- // currentJoin only written by this thread; only need ordered store
+ final int joinTask(ForkJoinTask<?> joinMe) {
ForkJoinTask<?> prevJoin = currentJoin;
- UNSAFE.putOrderedObject(this, currentJoinOffset, joinMe);
- pool.awaitJoin(joinMe, this, timed, nanos);
- UNSAFE.putOrderedObject(this, currentJoinOffset, prevJoin);
+ currentJoin = joinMe;
+ for (int s, retries = MAX_HELP;;) {
+ if ((s = joinMe.status) < 0) {
+ currentJoin = prevJoin;
+ return s;
+ }
+ if (retries > 0) {
+ if (queueTop != queueBase) {
+ if (!localHelpJoinTask(joinMe))
+ retries = 0; // cannot help
+ }
+ else if (retries == MAX_HELP >>> 1) {
+ --retries; // check uncommon case
+ if (tryDeqAndExec(joinMe) >= 0)
+ Thread.yield(); // for politeness
+ }
+ else
+ retries = helpJoinTask(joinMe)? MAX_HELP : retries - 1;
+ }
+ else {
+ retries = MAX_HELP; // restart if not done
+ pool.tryAwaitJoin(joinMe);
+ }
+ }
+ }
+
+ /**
+ * If present, pops and executes the given task, or any other
+ * cancelled task
+ *
+ * @return false if any other non-cancelled task exists in local queue
+ */
+ private boolean localHelpJoinTask(ForkJoinTask<?> joinMe) {
+ int s, i; ForkJoinTask<?>[] q; ForkJoinTask<?> t;
+ if ((s = queueTop) != queueBase && (q = queue) != null &&
+ (i = (q.length - 1) & --s) >= 0 &&
+ (t = q[i]) != null) {
+ if (t != joinMe && t.status >= 0)
+ return false;
+ if (UNSAFE.compareAndSwapObject
+ (q, (i << ASHIFT) + ABASE, t, null)) {
+ queueTop = s; // or putOrderedInt
+ t.doExec();
+ }
+ }
+ return true;
}
/**
- * Tries to locate and help perform tasks for a stealer of the
- * given task, or in turn one of its stealers. Traces
+ * Tries to locate and execute tasks for a stealer of the given
+ * task, or in turn one of its stealers, Traces
* currentSteal->currentJoin links looking for a thread working on
* a descendant of the given task and with a non-empty queue to
- * steal back and execute tasks from.
- *
- * The implementation is very branchy to cope with potential
- * inconsistencies or loops encountering chains that are stale,
- * unknown, or of length greater than MAX_HELP_DEPTH links. All
- * of these cases are dealt with by just returning back to the
- * caller, who is expected to retry if other join mechanisms also
- * don't work out.
+ * steal back and execute tasks from. The implementation is very
+ * branchy to cope with potential inconsistencies or loops
+ * encountering chains that are stale, unknown, or of length
+ * greater than MAX_HELP links. All of these cases are dealt with
+ * by just retrying by caller.
*
* @param joinMe the task to join
- * @param running if false, then must update pool count upon
- * running a task
- * @return value of running on exit
+ * @param canSteal true if local queue is empty
+ * @return true if ran a task
*/
- final boolean helpJoinTask(ForkJoinTask<?> joinMe, boolean running) {
- /*
- * Initial checks to (1) abort if terminating; (2) clean out
- * old cancelled tasks from local queue; (3) if joinMe is next
- * task, run it; (4) omit scan if local queue nonempty (since
- * it may contain non-descendents of joinMe).
- */
- ForkJoinPool p = pool;
- for (;;) {
- ForkJoinTask<?>[] q;
- int s;
- if (joinMe.status < 0)
- return running;
- else if ((runState & TERMINATING) != 0) {
- joinMe.cancelIgnoringExceptions();
- return running;
+ private boolean helpJoinTask(ForkJoinTask<?> joinMe) {
+ boolean helped = false;
+ int m = pool.scanGuard & SMASK;
+ ForkJoinWorkerThread[] ws = pool.workers;
+ if (ws != null && ws.length > m && joinMe.status >= 0) {
+ int levels = MAX_HELP; // remaining chain length
+ ForkJoinTask<?> task = joinMe; // base of chain
+ outer:for (ForkJoinWorkerThread thread = this;;) {
+ // Try to find v, the stealer of task, by first using hint
+ ForkJoinWorkerThread v = ws[thread.stealHint & m];
+ if (v == null || v.currentSteal != task) {
+ for (int j = 0; ;) { // search array
+ if ((v = ws[j]) != null && v.currentSteal == task) {
+ thread.stealHint = j;
+ break; // save hint for next time
+ }
+ if (++j > m)
+ break outer; // can't find stealer
+ }
+ }
+ // Try to help v, using specialized form of deqTask
+ for (;;) {
+ ForkJoinTask<?>[] q; int b, i;
+ if (joinMe.status < 0)
+ break outer;
+ if ((b = v.queueBase) == v.queueTop ||
+ (q = v.queue) == null ||
+ (i = (q.length-1) & b) < 0)
+ break; // empty
+ long u = (i << ASHIFT) + ABASE;
+ ForkJoinTask<?> t = q[i];
+ if (task.status < 0)
+ break outer; // stale
+ if (t != null && v.queueBase == b &&
+ UNSAFE.compareAndSwapObject(q, u, t, null)) {
+ v.queueBase = b + 1;
+ v.stealHint = poolIndex;
+ ForkJoinTask<?> ps = currentSteal;
+ currentSteal = t;
+ t.doExec();
+ currentSteal = ps;
+ helped = true;
+ }
+ }
+ // Try to descend to find v's stealer
+ ForkJoinTask<?> next = v.currentJoin;
+ if (--levels > 0 && task.status >= 0 &&
+ next != null && next != task) {
+ task = next;
+ thread = v;
+ }
+ else
+ break; // max levels, stale, dead-end, or cyclic
}
- else if ((s = sp) == base || (q = queue) == null)
- break; // queue empty
- else {
- int i = (q.length - 1) & --s;
- long u = (i << qShift) + qBase; // raw offset
- ForkJoinTask<?> t = q[i];
- if (t == null)
- break; // lost to a stealer
- else if (t != joinMe && t.status >= 0)
- return running; // cannot safely help
- else if ((running ||
- (running = p.tryIncrementRunningCount())) &&
- UNSAFE.compareAndSwapObject(q, u, t, null)) {
- sp = s; // putOrderedInt may encourage more timely write
- // UNSAFE.putOrderedInt(this, spOffset, s);
- t.quietlyExec();
+ }
+ return helped;
+ }
+
+ /**
+ * Performs an uncommon case for joinTask: If task t is at base of
+ * some workers queue, steals and executes it.
+ *
+ * @param t the task
+ * @return t's status
+ */
+ private int tryDeqAndExec(ForkJoinTask<?> t) {
+ int m = pool.scanGuard & SMASK;
+ ForkJoinWorkerThread[] ws = pool.workers;
+ if (ws != null && ws.length > m && t.status >= 0) {
+ for (int j = 0; j <= m; ++j) {
+ ForkJoinTask<?>[] q; int b, i;
+ ForkJoinWorkerThread v = ws[j];
+ if (v != null &&
+ (b = v.queueBase) != v.queueTop &&
+ (q = v.queue) != null &&
+ (i = (q.length - 1) & b) >= 0 &&
+ q[i] == t) {
+ long u = (i << ASHIFT) + ABASE;
+ if (v.queueBase == b &&
+ UNSAFE.compareAndSwapObject(q, u, t, null)) {
+ v.queueBase = b + 1;
+ v.stealHint = poolIndex;
+ ForkJoinTask<?> ps = currentSteal;
+ currentSteal = t;
+ t.doExec();
+ currentSteal = ps;
+ }
+ break;
}
}
}
-
- int n; // worker array size
- ForkJoinWorkerThread[] ws = p.workers;
- if (ws != null && (n = ws.length) > 1) { // need at least 2 workers
- ForkJoinTask<?> task = joinMe; // base of chain
- ForkJoinWorkerThread thread = this; // thread with stolen task
-
- outer:for (int d = 0; d < MAX_HELP_DEPTH; ++d) { // chain length
- // Try to find v, the stealer of task, by first using hint
- ForkJoinWorkerThread v = ws[thread.stealHint & (n - 1)];
- if (v == null || v.currentSteal != task) {
- for (int j = 0; ; ++j) { // search array
- if (j < n) {
- ForkJoinTask<?> vs;
- if ((v = ws[j]) != null &&
- (vs = v.currentSteal) != null) {
- if (joinMe.status < 0)
- break outer;
- if (vs == task) {
- if (task.status < 0)
- break outer; // stale
- thread.stealHint = j;
- break; // save hint for next time
- }
- }
- }
- else
- break outer; // no stealer
- }
- }
-
- // Try to help v, using specialized form of deqTask
- for (;;) {
- if (joinMe.status < 0)
- break outer;
- int b = v.base;
- ForkJoinTask<?>[] q = v.queue;
- if (b == v.sp || q == null)
- break; // empty
- int i = (q.length - 1) & b;
- long u = (i << qShift) + qBase;
- ForkJoinTask<?> t = q[i];
- if (task.status < 0)
- break outer; // stale
- if (t != null &&
- (running ||
- (running = p.tryIncrementRunningCount())) &&
- v.base == b++ &&
- UNSAFE.compareAndSwapObject(q, u, t, null)) {
- if (t != joinMe && joinMe.status < 0) {
- UNSAFE.putObjectVolatile(q, u, t);
- break outer; // joinMe cancelled; back out
- }
- v.base = b;
- if (t.status >= 0) {
- ForkJoinTask<?> ps = currentSteal;
- int pid = poolIndex;
- v.stealHint = pid;
- UNSAFE.putOrderedObject(this,
- currentStealOffset, t);
- t.quietlyExec();
- UNSAFE.putOrderedObject(this,
- currentStealOffset, ps);
- }
- }
- else if ((runState & TERMINATING) != 0) {
- joinMe.cancelIgnoringExceptions();
- break outer;
- }
- }
-
- // Try to descend to find v's stealer
- ForkJoinTask<?> next = v.currentJoin;
- if (task.status < 0 || next == null || next == task ||
- joinMe.status < 0)
- break; // done, stale, dead-end, or cyclic
- task = next;
- thread = v;
- }
- }
- return running;
+ return t.status;
}
/**
- * Implements ForkJoinTask.getSurplusQueuedTaskCount().
- * Returns an estimate of the number of tasks, offset by a
- * function of number of idle workers.
+ * Implements ForkJoinTask.getSurplusQueuedTaskCount(). Returns
+ * an estimate of the number of tasks, offset by a function of
+ * number of idle workers.
*
* This method provides a cheap heuristic guide for task
* partitioning when programmers, frameworks, tools, or languages
@@ -1159,82 +903,96 @@
* When all threads are active, it is on average OK to estimate
* surplus strictly locally. In steady-state, if one thread is
* maintaining say 2 surplus tasks, then so are others. So we can
- * just use estimated queue length (although note that (sp - base)
- * can be an overestimate because of stealers lagging increments
- * of base). However, this strategy alone leads to serious
- * mis-estimates in some non-steady-state conditions (ramp-up,
- * ramp-down, other stalls). We can detect many of these by
- * further considering the number of "idle" threads, that are
+ * just use estimated queue length (although note that (queueTop -
+ * queueBase) can be an overestimate because of stealers lagging
+ * increments of queueBase). However, this strategy alone leads
+ * to serious mis-estimates in some non-steady-state conditions
+ * (ramp-up, ramp-down, other stalls). We can detect many of these
+ * by further considering the number of "idle" threads, that are
* known to have zero queued tasks, so compensate by a factor of
* (#idle/#active) threads.
*/
final int getEstimatedSurplusTaskCount() {
- return sp - base - pool.idlePerActive();
+ return queueTop - queueBase - pool.idlePerActive();
}
/**
- * Runs tasks until {@code pool.isQuiescent()}.
+ * Runs tasks until {@code pool.isQuiescent()}. We piggyback on
+ * pool's active count ctl maintenance, but rather than blocking
+ * when tasks cannot be found, we rescan until all others cannot
+ * find tasks either. The bracketing by pool quiescerCounts
+ * updates suppresses pool auto-shutdown mechanics that could
+ * otherwise prematurely terminate the pool because all threads
+ * appear to be inactive.
*/
final void helpQuiescePool() {
+ boolean active = true;
ForkJoinTask<?> ps = currentSteal; // to restore below
+ ForkJoinPool p = pool;
+ p.addQuiescerCount(1);
for (;;) {
- ForkJoinTask<?> t = pollLocalTask();
- if (t != null || (t = scan()) != null)
- t.quietlyExec();
+ ForkJoinWorkerThread[] ws = p.workers;
+ ForkJoinWorkerThread v = null;
+ int n;
+ if (queueTop != queueBase)
+ v = this;
+ else if (ws != null && (n = ws.length) > 1) {
+ ForkJoinWorkerThread w;
+ int r = nextSeed(); // cheap version of FJP.scan
+ int steps = n << 1;
+ for (int i = 0; i < steps; ++i) {
+ if ((w = ws[(i + r) & (n - 1)]) != null &&
+ w.queueBase != w.queueTop) {
+ v = w;
+ break;
+ }
+ }
+ }
+ if (v != null) {
+ ForkJoinTask<?> t;
+ if (!active) {
+ active = true;
+ p.addActiveCount(1);
+ }
+ if ((t = (v != this) ? v.deqTask() :
+ locallyFifo? locallyDeqTask() : popTask()) != null) {
+ currentSteal = t;
+ t.doExec();
+ currentSteal = ps;
+ }
+ }
else {
- ForkJoinPool p = pool;
- int a; // to inline CASes
if (active) {
- if (!UNSAFE.compareAndSwapInt
- (p, poolRunStateOffset, a = p.runState, a - 1))
- continue; // retry later
- active = false; // inactivate
- UNSAFE.putOrderedObject(this, currentStealOffset, ps);
+ active = false;
+ p.addActiveCount(-1);
}
if (p.isQuiescent()) {
- active = true; // re-activate
- do {} while (!UNSAFE.compareAndSwapInt
- (p, poolRunStateOffset, a = p.runState, a+1));
- return;
+ p.addActiveCount(1);
+ p.addQuiescerCount(-1);
+ break;
}
}
}
}
// Unsafe mechanics
-
- private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
- private static final long spOffset =
- objectFieldOffset("sp", ForkJoinWorkerThread.class);
- private static final long runStateOffset =
- objectFieldOffset("runState", ForkJoinWorkerThread.class);
- private static final long currentJoinOffset =
- objectFieldOffset("currentJoin", ForkJoinWorkerThread.class);
- private static final long currentStealOffset =
- objectFieldOffset("currentSteal", ForkJoinWorkerThread.class);
- private static final long qBase =
- UNSAFE.arrayBaseOffset(ForkJoinTask[].class);
- private static final long poolRunStateOffset = // to inline CAS
- objectFieldOffset("runState", ForkJoinPool.class);
-
- private static final int qShift;
+ private static final sun.misc.Unsafe UNSAFE;
+ private static final long ABASE;
+ private static final int ASHIFT;
static {
- int s = UNSAFE.arrayIndexScale(ForkJoinTask[].class);
+ int s;
+ try {
+ UNSAFE = sun.misc.Unsafe.getUnsafe();
+ Class a = ForkJoinTask[].class;
+ ABASE = UNSAFE.arrayBaseOffset(a);
+ s = UNSAFE.arrayIndexScale(a);
+ } catch (Exception e) {
+ throw new Error(e);
+ }
if ((s & (s-1)) != 0)
throw new Error("data type scale not a power of two");
- qShift = 31 - Integer.numberOfLeadingZeros(s);
- MAXIMUM_QUEUE_CAPACITY = 1 << (31 - qShift);
+ ASHIFT = 31 - Integer.numberOfLeadingZeros(s);
}
- private static long objectFieldOffset(String field, Class<?> klazz) {
- try {
- return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
- } catch (NoSuchFieldException e) {
- // Convert Exception to corresponding Error
- NoSuchFieldError error = new NoSuchFieldError(field);
- error.initCause(e);
- throw error;
- }
- }
}
--- a/jdk/src/share/classes/org/relaxng/datatype/Datatype.java Mon Mar 21 16:55:14 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,262 +0,0 @@
-/*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package org.relaxng.datatype;
-
-/**
- * Datatype object.
- *
- * This object has the following functionality:
- *
- * <ol>
- * <li> functionality to identify a class of character sequences. This is
- * done through the isValid method.
- *
- * <li> functionality to produce a "value object" from a character sequence and
- * context information.
- *
- * <li> functionality to test the equality of two value objects.
- * </ol>
- *
- * This interface also defines the createStreamingValidator method,
- * which is intended to efficiently support the validation of
- * large character sequences.
- *
- * @author <a href="mailto:jjc@jclark.com">James Clark</a>
- * @author <a href="mailto:kohsuke.kawaguchi@sun.com">Kohsuke KAWAGUCHI</a>
- */
-public interface Datatype {
-
- /**
- * Checks if the specified 'literal' matches this Datatype
- * with respect to the current context.
- *
- * @param literal
- * the lexical representation to be checked.
- * @param context
- * If this datatype is context-dependent
- * (i.e. the {@link #isContextDependent} method returns true),
- * then the caller must provide a non-null valid context object.
- * Otherwise, the caller can pass null.
- *
- * @return
- * true if the 'literal' is a member of this Datatype;
- * false if it's not a member of this Datatype.
- */
- boolean isValid( String literal, ValidationContext context );
-
- /**
- * Similar to the isValid method but throws an exception with diagnosis
- * in case of errors.
- *
- * <p>
- * If the specified 'literal' is a valid lexical representation for this
- * datatype, then this method must return without throwing any exception.
- * If not, the callee must throw an exception (with diagnosis message,
- * if possible.)
- *
- * <p>
- * The application can use this method to provide detailed error message
- * to users. This method is kept separate from the isValid method to
- * achieve higher performance during normal validation.
- *
- * @exception DatatypeException
- * If the given literal is invalid, then this exception is thrown.
- * If the callee supports error diagnosis, then the exception should
- * contain a diagnosis message.
- */
- void checkValid( String literal, ValidationContext context )
- throws DatatypeException;
-
- /**
- * Creates an instance of a streaming validator for this type.
- *
- * <p>
- * By using streaming validators instead of the isValid method,
- * the caller can avoid keeping the entire string, which is
- * sometimes quite big, in memory.
- *
- * @param context
- * If this datatype is context-dependent
- * (i.e. the {@link #isContextDependent} method returns true),
- * then the caller must provide a non-null valid context object.
- * Otherwise, the caller can pass null.
- * The callee may keep a reference to this context object
- * only while the returned streaming validator is being used.
- */
- DatatypeStreamingValidator createStreamingValidator( ValidationContext context );
-
- /**
- * Converts lexcial value and the current context to the corresponding
- * value object.
- *
- * <p>
- * The caller cannot generally assume that the value object is
- * a meaningful Java object. For example, the caller cannot expect
- * this method to return <code>java.lang.Number</code> type for
- * the "integer" type of XML Schema Part 2.
- *
- * <p>
- * Also, the caller cannot assume that the equals method and
- * the hashCode method of the value object are consistent with
- * the semantics of the datatype. For that purpose, the sameValue
- * method and the valueHashCode method have to be used. Note that
- * this means you cannot use classes like
- * <code>java.util.Hashtable</code> to store the value objects.
- *
- * <p>
- * The returned value object should be used solely for the sameValue
- * and valueHashCode methods.
- *
- * @param context
- * If this datatype is context-dependent
- * (when the {@link #isContextDependent} method returns true),
- * then the caller must provide a non-null valid context object.
- * Otherwise, the caller can pass null.
- *
- * @return null
- * when the given lexical value is not a valid lexical
- * value for this type.
- */
- Object createValue( String literal, ValidationContext context );
-
- /**
- * Tests the equality of two value objects which were originally
- * created by the createValue method of this object.
- *
- * The behavior is undefined if objects not created by this type
- * are passed. It is the caller's responsibility to ensure that
- * value objects belong to this type.
- *
- * @return
- * true if two value objects are considered equal according to
- * the definition of this datatype; false if otherwise.
- */
- boolean sameValue( Object value1, Object value2 );
-
-
- /**
- * Computes the hash code for a value object,
- * which is consistent with the sameValue method.
- *
- * @return
- * hash code for the specified value object.
- */
- int valueHashCode( Object value );
-
-
-
-
- /**
- * Indicates that the datatype doesn't have ID/IDREF semantics.
- *
- * This value is one of the possible return values of the
- * {@link #getIdType} method.
- */
- public static final int ID_TYPE_NULL = 0;
-
- /**
- * Indicates that RELAX NG compatibility processors should
- * treat this datatype as having ID semantics.
- *
- * This value is one of the possible return values of the
- * {@link #getIdType} method.
- */
- public static final int ID_TYPE_ID = 1;
-
- /**
- * Indicates that RELAX NG compatibility processors should
- * treat this datatype as having IDREF semantics.
- *
- * This value is one of the possible return values of the
- * {@link #getIdType} method.
- */
- public static final int ID_TYPE_IDREF = 2;
-
- /**
- * Indicates that RELAX NG compatibility processors should
- * treat this datatype as having IDREFS semantics.
- *
- * This value is one of the possible return values of the
- * {@link #getIdType} method.
- */
- public static final int ID_TYPE_IDREFS = 3;
-
- /**
- * Checks if the ID/IDREF semantics is associated with this
- * datatype.
- *
- * <p>
- * This method is introduced to support the RELAX NG DTD
- * compatibility spec. (Of course it's always free to use
- * this method for other purposes.)
- *
- * <p>
- * If you are implementing a datatype library and have no idea about
- * the "RELAX NG DTD compatibility" thing, just return
- * <code>ID_TYPE_NULL</code> is fine.
- *
- * @return
- * If this datatype doesn't have any ID/IDREF semantics,
- * it returns {@link #ID_TYPE_NULL}. If it has such a semantics
- * (for example, XSD:ID, XSD:IDREF and comp:ID type), then
- * it returns {@link #ID_TYPE_ID}, {@link #ID_TYPE_IDREF} or
- * {@link #ID_TYPE_IDREFS}.
- */
- public int getIdType();
-
-
- /**
- * Checks if this datatype may need a context object for
- * the validation.
- *
- * <p>
- * The callee must return true even when the context
- * is not always necessary. (For example, the "QName" type
- * doesn't need a context object when validating unprefixed
- * string. But nonetheless QName must return true.)
- *
- * <p>
- * XSD's <code>string</code> and <code>short</code> types
- * are examples of context-independent datatypes.
- * Its <code>QName</code> and <code>ENTITY</code> types
- * are examples of context-dependent datatypes.
- *
- * <p>
- * When a datatype is context-independent, then
- * the {@link #isValid} method, the {@link #checkValid} method,
- * the {@link #createStreamingValidator} method and
- * the {@link #createValue} method can be called without
- * providing a context object.
- *
- * @return
- * <b>true</b> if this datatype is context-dependent
- * (it needs a context object sometimes);
- *
- * <b>false</b> if this datatype is context-<b>in</b>dependent
- * (it never needs a context object).
- */
- public boolean isContextDependent();
-}
--- a/jdk/src/share/classes/org/relaxng/datatype/DatatypeBuilder.java Mon Mar 21 16:55:14 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,70 +0,0 @@
-/*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package org.relaxng.datatype;
-
-/**
- * Creates a user-defined type by adding parameters to
- * the pre-defined type.
- *
- * @author <a href="mailto:jjc@jclark.com">James Clark</a>
- * @author <a href="mailto:kohsuke.kawaguchi@sun.com">Kohsuke KAWAGUCHI</a>
- */
-public interface DatatypeBuilder {
-
- /**
- * Adds a new parameter.
- *
- * @param name
- * The name of the parameter to be added.
- * @param strValue
- * The raw value of the parameter. Caller may not normalize
- * this value because any white space is potentially significant.
- * @param context
- * The context information which can be used by the callee to
- * acquire additional information. This context object is
- * valid only during this method call. The callee may not
- * keep a reference to this object.
- * @exception DatatypeException
- * When the given parameter is inappropriate for some reason.
- * The callee is responsible to recover from this error.
- * That is, the object should behave as if no such error
- * was occured.
- */
- void addParameter( String name, String strValue, ValidationContext context )
- throws DatatypeException;
-
- /**
- * Derives a new Datatype from a Datatype by parameters that
- * were already set through the addParameter method.
- *
- * @exception DatatypeException
- * DatatypeException must be thrown if the derivation is
- * somehow invalid. For example, a required parameter is missing,
- * etc. The exception should contain a diagnosis message
- * if possible.
- */
- Datatype createDatatype() throws DatatypeException;
-}
--- a/jdk/src/share/classes/org/relaxng/datatype/DatatypeException.java Mon Mar 21 16:55:14 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,64 +0,0 @@
-/*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package org.relaxng.datatype;
-
-/**
- * Signals Datatype related exceptions.
- *
- * @author <a href="mailto:jjc@jclark.com">James Clark</a>
- * @author <a href="mailto:kohsuke.kawaguchi@sun.com">Kohsuke KAWAGUCHI</a>
- */
-public class DatatypeException extends Exception {
-
- public DatatypeException( int index, String msg ) {
- super(msg);
- this.index = index;
- }
- public DatatypeException( String msg ) {
- this(UNKNOWN,msg);
- }
- /**
- * A constructor for those datatype libraries which don't support any
- * diagnostic information at all.
- */
- public DatatypeException() {
- this(UNKNOWN,null);
- }
-
-
- private final int index;
-
- public static final int UNKNOWN = -1;
-
- /**
- * Gets the index of the content where the error occured.
- * UNKNOWN can be returned to indicate that no index information
- * is available.
- */
- public int getIndex() {
- return index;
- }
-}
--- a/jdk/src/share/classes/org/relaxng/datatype/DatatypeLibrary.java Mon Mar 21 16:55:14 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,62 +0,0 @@
-/*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package org.relaxng.datatype;
-
-/**
- * A Datatype library
- *
- * @author <a href="mailto:jjc@jclark.com">James Clark</a>
- * @author <a href="mailto:kohsuke.kawaguchi@sun.com">Kohsuke KAWAGUCHI</a>
- */
-public interface DatatypeLibrary {
-
- /**
- * Creates a new instance of DatatypeBuilder.
- *
- * The callee should throw a DatatypeException in case of an error.
- *
- * @param baseTypeLocalName
- * The local name of the base type.
- *
- * @return
- * A non-null valid datatype object.
- */
- DatatypeBuilder createDatatypeBuilder( String baseTypeLocalName )
- throws DatatypeException;
-
- /**
- * Gets or creates a pre-defined type.
- *
- * This is just a short-cut of
- * <code>createDatatypeBuilder(typeLocalName).createDatatype();</code>
- *
- * The callee should throw a DatatypeException in case of an error.
- *
- * @return
- * A non-null valid datatype object.
- */
- Datatype createDatatype( String typeLocalName ) throws DatatypeException;
-}
--- a/jdk/src/share/classes/org/relaxng/datatype/DatatypeLibraryFactory.java Mon Mar 21 16:55:14 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package org.relaxng.datatype;
-
-/**
- * Factory class for the DatatypeLibrary class.
- *
- * <p>
- * The datatype library should provide the implementation of
- * this interface if it wants to be found by the schema processors.
- * The implementor also have to place a file in your jar file.
- * See the reference datatype library implementation for detail.
- *
- * @author <a href="mailto:jjc@jclark.com">James Clark</a>
- * @author <a href="mailto:kohsuke.kawaguchi@sun.com">Kohsuke KAWAGUCHI</a>
- */
-public interface DatatypeLibraryFactory
-{
- /**
- * Creates a new instance of a DatatypeLibrary that supports
- * the specified namespace URI.
- *
- * @return
- * <code>null</code> if the specified namespace URI is not
- * supported.
- */
- DatatypeLibrary createDatatypeLibrary( String namespaceURI );
-}
--- a/jdk/src/share/classes/org/relaxng/datatype/DatatypeStreamingValidator.java Mon Mar 21 16:55:14 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package org.relaxng.datatype;
-
-/**
- * Datatype streaming validator.
- *
- * <p>
- * The streaming validator is an optional feature that is useful for
- * certain Datatypes. It allows the caller to incrementally provide
- * the literal.
- *
- * @author <a href="mailto:jjc@jclark.com">James Clark</a>
- * @author <a href="mailto:kohsuke.kawaguchi@sun.com">Kohsuke KAWAGUCHI</a>
- */
-public interface DatatypeStreamingValidator {
-
- /**
- * Passes an additional fragment of the literal.
- *
- * <p>
- * The application can call this method several times, then call
- * the isValid method (or the checkValid method) to check the validity
- * of the accumulated characters.
- */
- void addCharacters( char[] buf, int start, int len );
-
- /**
- * Tells if the accumulated literal is valid with respect to
- * the underlying Datatype.
- *
- * @return
- * True if it is valid. False if otherwise.
- */
- boolean isValid();
-
- /**
- * Similar to the isValid method, but this method throws
- * Exception (with possibly diagnostic information), instead of
- * returning false.
- *
- * @exception DatatypeException
- * If the callee supports the diagnosis and the accumulated
- * literal is invalid, then this exception that possibly
- * contains diagnosis information is thrown.
- */
- void checkValid() throws DatatypeException;
-}
--- a/jdk/src/share/classes/org/relaxng/datatype/ValidationContext.java Mon Mar 21 16:55:14 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,91 +0,0 @@
-/*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package org.relaxng.datatype;
-
-/**
- * An interface that must be implemented by caller to
- * provide context information that is necessary to
- * perform validation of some Datatypes.
- *
- * @author <a href="mailto:jjc@jclark.com">James Clark</a>
- * @author <a href="mailto:kohsuke.kawaguchi@sun.com">Kohsuke KAWAGUCHI</a>
- */
-public interface ValidationContext {
-
- /**
- * Resolves a namespace prefix to the corresponding namespace URI.
- *
- * This method is used for validating the QName type, for example.
- *
- * <p>
- * If the prefix is "" (empty string), it indicates
- * an unprefixed value. The callee
- * should resolve it as for an unprefixed
- * element, rather than for an unprefixed attribute.
- *
- * <p>
- * If the prefix is "xml", then the callee must resolve
- * this prefix into "http://www.w3.org/XML/1998/namespace",
- * as defined in the XML Namespaces Recommendation.
- *
- * @return
- * namespace URI of this prefix.
- * If the specified prefix is not declared,
- * the implementation must return null.
- */
- String resolveNamespacePrefix( String prefix );
-
- /**
- * Returns the base URI of the context. The null string may be returned
- * if no base URI is known.
- */
- String getBaseUri();
-
- /**
- * Checks if an unparsed entity is declared with the
- * specified name.
- *
- * @return
- * true
- * if the DTD has an unparsed entity declaration for
- * the specified name.
- * false
- * otherwise.
- */
- boolean isUnparsedEntity( String entityName );
-
- /**
- * Checks if a notation is declared with the
- * specified name.
- *
- * @return
- * true
- * if the DTD has a notation declaration for the specified name.
- * false
- * otherwise.
- */
- boolean isNotation( String notationName );
-}
--- a/jdk/src/share/classes/org/relaxng/datatype/helpers/DatatypeLibraryLoader.java Mon Mar 21 16:55:14 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,262 +0,0 @@
-/**
- * Copyright (c) 2001, Thai Open Source Software Center Ltd
- * 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.
- *
- * Neither the name of the Thai Open Source Software Center Ltd nor
- * the names of its contributors may be used to endorse or promote
- * products derived from this software without specific prior written
- * permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 REGENTS 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.
- */
-package org.relaxng.datatype.helpers;
-
-import org.relaxng.datatype.DatatypeLibraryFactory;
-import org.relaxng.datatype.DatatypeLibrary;
-import java.util.Enumeration;
-import java.util.NoSuchElementException;
-import java.util.Vector;
-import java.io.Reader;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.UnsupportedEncodingException;
-import java.net.URL;
-
-/**
- * Discovers the datatype library implementation from the classpath.
- *
- * <p>
- * The call of the createDatatypeLibrary method finds an implementation
- * from a given datatype library URI at run-time.
- */
-public class DatatypeLibraryLoader implements DatatypeLibraryFactory {
- private final Service service = new Service(DatatypeLibraryFactory.class);
-
- public DatatypeLibrary createDatatypeLibrary(String uri) {
- for (Enumeration e = service.getProviders();
- e.hasMoreElements();) {
- DatatypeLibraryFactory factory
- = (DatatypeLibraryFactory)e.nextElement();
- DatatypeLibrary library = factory.createDatatypeLibrary(uri);
- if (library != null)
- return library;
- }
- return null;
- }
-
- private static class Service {
- private final Class serviceClass;
- private final Enumeration configFiles;
- private Enumeration classNames = null;
- private final Vector providers = new Vector();
- private Loader loader;
-
- private class ProviderEnumeration implements Enumeration {
- private int nextIndex = 0;
-
- public boolean hasMoreElements() {
- return nextIndex < providers.size() || moreProviders();
- }
-
- public Object nextElement() {
- try {
- return providers.elementAt(nextIndex++);
- }
- catch (ArrayIndexOutOfBoundsException e) {
- throw new NoSuchElementException();
- }
- }
- }
-
- private static class Singleton implements Enumeration {
- private Object obj;
- private Singleton(Object obj) {
- this.obj = obj;
- }
-
- public boolean hasMoreElements() {
- return obj != null;
- }
-
- public Object nextElement() {
- if (obj == null)
- throw new NoSuchElementException();
- Object tem = obj;
- obj = null;
- return tem;
- }
- }
-
- // JDK 1.1
- private static class Loader {
- Enumeration getResources(String resName) {
- ClassLoader cl = Loader.class.getClassLoader();
- URL url;
- if (cl == null)
- url = ClassLoader.getSystemResource(resName);
- else
- url = cl.getResource(resName);
- return new Singleton(url);
- }
-
- Class loadClass(String name) throws ClassNotFoundException {
- return Class.forName(name);
- }
- }
-
- // JDK 1.2+
- private static class Loader2 extends Loader {
- private ClassLoader cl;
-
- Loader2() {
- cl = Loader2.class.getClassLoader();
- // If the thread context class loader has the class loader
- // of this class as an ancestor, use the thread context class
- // loader. Otherwise, the thread context class loader
- // probably hasn't been set up properly, so don't use it.
- ClassLoader clt = Thread.currentThread().getContextClassLoader();
- for (ClassLoader tem = clt; tem != null; tem = tem.getParent())
- if (tem == cl) {
- cl = clt;
- break;
- }
- }
-
- Enumeration getResources(String resName) {
- try {
- return cl.getResources(resName);
-
- }
- catch (IOException e) {
- return new Singleton(null);
- }
- }
-
- Class loadClass(String name) throws ClassNotFoundException {
- return Class.forName(name, true, cl);
- }
- }
-
- public Service(Class cls) {
- try {
- loader = new Loader2();
- }
- catch (NoSuchMethodError e) {
- loader = new Loader();
- }
- serviceClass = cls;
- String resName = "META-INF/services/" + serviceClass.getName();
- configFiles = loader.getResources(resName);
- }
-
- public Enumeration getProviders() {
- return new ProviderEnumeration();
- }
-
- synchronized private boolean moreProviders() {
- for (;;) {
- while (classNames == null) {
- if (!configFiles.hasMoreElements())
- return false;
- classNames = parseConfigFile((URL)configFiles.nextElement());
- }
- while (classNames.hasMoreElements()) {
- String className = (String)classNames.nextElement();
- try {
- Class cls = loader.loadClass(className);
- Object obj = cls.newInstance();
- if (serviceClass.isInstance(obj)) {
- providers.addElement(obj);
- return true;
- }
- }
- catch (ClassNotFoundException e) { }
- catch (InstantiationException e) { }
- catch (IllegalAccessException e) { }
- catch (LinkageError e) { }
- }
- classNames = null;
- }
- }
-
- private static final int START = 0;
- private static final int IN_NAME = 1;
- private static final int IN_COMMENT = 2;
-
- private static Enumeration parseConfigFile(URL url) {
- try {
- InputStream in = url.openStream();
- Reader r;
- try {
- r = new InputStreamReader(in, "UTF-8");
- }
- catch (UnsupportedEncodingException e) {
- r = new InputStreamReader(in, "UTF8");
- }
- r = new BufferedReader(r);
- Vector tokens = new Vector();
- StringBuffer tokenBuf = new StringBuffer();
- int state = START;
- for (;;) {
- int n = r.read();
- if (n < 0)
- break;
- char c = (char)n;
- switch (c) {
- case '\r':
- case '\n':
- state = START;
- break;
- case ' ':
- case '\t':
- break;
- case '#':
- state = IN_COMMENT;
- break;
- default:
- if (state != IN_COMMENT) {
- state = IN_NAME;
- tokenBuf.append(c);
- }
- break;
- }
- if (tokenBuf.length() != 0 && state != IN_NAME) {
- tokens.addElement(tokenBuf.toString());
- tokenBuf.setLength(0);
- }
- }
- if (tokenBuf.length() != 0)
- tokens.addElement(tokenBuf.toString());
- return tokens.elements();
- }
- catch (IOException e) {
- return null;
- }
- }
- }
-
-}
--- a/jdk/src/share/classes/org/relaxng/datatype/helpers/ParameterlessDatatypeBuilder.java Mon Mar 21 16:55:14 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package org.relaxng.datatype.helpers;
-
-import org.relaxng.datatype.*;
-
-/**
- * Dummy implementation of {@link DatatypeBuilder}.
- *
- * This implementation can be used for Datatypes which have no parameters.
- * Any attempt to add parameters will be rejected.
- *
- * <p>
- * Typical usage would be:
- * <PRE><XMP>
- * class MyDatatypeLibrary implements DatatypeLibrary {
- * ....
- * DatatypeBuilder createDatatypeBuilder( String typeName ) {
- * return new ParameterleessDatatypeBuilder(createDatatype(typeName));
- * }
- * ....
- * }
- * </XMP></PRE>
- *
- * @author <a href="mailto:kohsuke.kawaguchi@sun.com">Kohsuke KAWAGUCHI</a>
- */
-public final class ParameterlessDatatypeBuilder implements DatatypeBuilder {
-
- /** This type object is returned for the derive method. */
- private final Datatype baseType;
-
- public ParameterlessDatatypeBuilder( Datatype baseType ) {
- this.baseType = baseType;
- }
-
- public void addParameter( String name, String strValue, ValidationContext context )
- throws DatatypeException {
- throw new DatatypeException();
- }
-
- public Datatype createDatatype() throws DatatypeException {
- return baseType;
- }
-}
--- a/jdk/src/share/classes/org/relaxng/datatype/helpers/StreamingValidatorImpl.java Mon Mar 21 16:55:14 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package org.relaxng.datatype.helpers;
-
-import org.relaxng.datatype.*;
-
-/**
- * Dummy implementation of {@link DatatypeStreamingValidator}.
- *
- * <p>
- * This implementation can be used as a quick hack when the performance
- * of streaming validation is not important. And this implementation
- * also shows you how to implement the DatatypeStreamingValidator interface.
- *
- * <p>
- * Typical usage would be:
- * <PRE><XMP>
- * class MyDatatype implements Datatype {
- * ....
- * public DatatypeStreamingValidator createStreamingValidator( ValidationContext context ) {
- * return new StreamingValidatorImpl(this,context);
- * }
- * ....
- * }
- * </XMP></PRE>
- *
- * @author <a href="mailto:kohsuke.kawaguchi@sun.com">Kohsuke KAWAGUCHI</a>
- */
-public final class StreamingValidatorImpl implements DatatypeStreamingValidator {
-
- /** This buffer accumulates characters. */
- private final StringBuffer buffer = new StringBuffer();
-
- /** Datatype obejct that creates this streaming validator. */
- private final Datatype baseType;
-
- /** The current context. */
- private final ValidationContext context;
-
- public void addCharacters( char[] buf, int start, int len ) {
- // append characters to the current buffer.
- buffer.append(buf,start,len);
- }
-
- public boolean isValid() {
- return baseType.isValid(buffer.toString(),context);
- }
-
- public void checkValid() throws DatatypeException {
- baseType.checkValid(buffer.toString(),context);
- }
-
- public StreamingValidatorImpl( Datatype baseType, ValidationContext context ) {
- this.baseType = baseType;
- this.context = context;
- }
-}
--- a/jdk/src/share/classes/sun/launcher/LauncherHelper.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/launcher/LauncherHelper.java Mon Mar 21 16:57:18 2011 -0700
@@ -42,10 +42,12 @@
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.math.RoundingMode;
+import java.nio.charset.Charset;
import java.util.ResourceBundle;
import java.text.MessageFormat;
import java.util.ArrayList;
@@ -471,11 +473,11 @@
} catch (ClassNotFoundException cnfe) {
abort(ostream, cnfe, "java.launcher.cls.error1", cn);
}
- signatureDiagnostic(ostream, c);
+ getMainMethod(ostream, c);
return c;
}
- static void signatureDiagnostic(PrintStream ostream, Class<?> clazz) {
+ static Method getMainMethod(PrintStream ostream, Class<?> clazz) {
String classname = clazz.getName();
Method method = null;
try {
@@ -495,6 +497,31 @@
if (method.getReturnType() != java.lang.Void.TYPE) {
abort(ostream, null, "java.launcher.cls.error3", classname);
}
- return;
+ return method;
+ }
+
+ private static final String encprop = "sun.jnu.encoding";
+ private static String encoding = null;
+ private static boolean isCharsetSupported = false;
+
+ /*
+ * converts a c or a byte array to a platform specific string,
+ * previously implemented as a native method in the launcher.
+ */
+ static String makePlatformString(boolean printToStderr, byte[] inArray) {
+ final PrintStream ostream = (printToStderr) ? System.err : System.out;
+ if (encoding == null) {
+ encoding = System.getProperty(encprop);
+ isCharsetSupported = Charset.isSupported(encoding);
+ }
+ try {
+ String out = isCharsetSupported
+ ? new String(inArray, encoding)
+ : new String(inArray);
+ return out;
+ } catch (UnsupportedEncodingException uee) {
+ abort(ostream, uee, null);
+ }
+ return null; // keep the compiler happy
}
}
--- a/jdk/src/share/classes/sun/nio/ch/DatagramChannelImpl.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/nio/ch/DatagramChannelImpl.java Mon Mar 21 16:57:18 2011 -0700
@@ -755,11 +755,14 @@
throw new IllegalArgumentException("Group not a multicast address");
// check multicast address is compatible with this socket
- if (!(group instanceof Inet4Address)) {
- if (family == StandardProtocolFamily.INET)
- throw new IllegalArgumentException("Group is not IPv4 address");
- if (!(group instanceof Inet6Address))
- throw new IllegalArgumentException("Address type not supported");
+ if (group instanceof Inet4Address) {
+ if (family == StandardProtocolFamily.INET6 && !Net.canIPv6SocketJoinIPv4Group())
+ throw new IllegalArgumentException("Group is not IPv4 multicast address");
+ } else if (group instanceof Inet6Address) {
+ if (family != StandardProtocolFamily.INET6)
+ throw new IllegalArgumentException("Group is not IPv6 multicast address");
+ } else {
+ throw new IllegalArgumentException("Address type not supported");
}
// check source address
@@ -791,7 +794,9 @@
}
MembershipKeyImpl key;
- if (family == StandardProtocolFamily.INET6) {
+ if ((family == StandardProtocolFamily.INET6) &&
+ ((group instanceof Inet6Address) || Net.canJoin6WithIPv4Group()))
+ {
int index = interf.getIndex();
if (index == -1)
throw new IOException("Network interface cannot be identified");
@@ -861,7 +866,7 @@
return;
try {
- if (family == StandardProtocolFamily.INET6) {
+ if (key instanceof MembershipKeyImpl.Type6) {
MembershipKeyImpl.Type6 key6 =
(MembershipKeyImpl.Type6)key;
Net.drop6(fd, key6.groupAddress(), key6.index(), key6.source());
@@ -901,7 +906,7 @@
throw new IllegalArgumentException("Source address is different type to group");
int n;
- if (family == StandardProtocolFamily.INET6) {
+ if (key instanceof MembershipKeyImpl.Type6) {
MembershipKeyImpl.Type6 key6 =
(MembershipKeyImpl.Type6)key;
n = Net.block6(fd, key6.groupAddress(), key6.index(),
@@ -931,7 +936,7 @@
throw new IllegalStateException("key is no longer valid");
try {
- if (family == StandardProtocolFamily.INET6) {
+ if (key instanceof MembershipKeyImpl.Type6) {
MembershipKeyImpl.Type6 key6 =
(MembershipKeyImpl.Type6)key;
Net.unblock6(fd, key6.groupAddress(), key6.index(),
--- a/jdk/src/share/classes/sun/nio/ch/Net.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/nio/ch/Net.java Mon Mar 21 16:57:18 2011 -0700
@@ -60,6 +60,21 @@
return isIPv6Available;
}
+ /**
+ * Tells whether IPv6 sockets can join IPv4 multicast groups
+ */
+ static boolean canIPv6SocketJoinIPv4Group() {
+ return canIPv6SocketJoinIPv4Group0();
+ }
+
+ /**
+ * Tells whether {@link #join6} can be used to join an IPv4
+ * multicast group (IPv4 group as IPv4-mapped IPv6 address)
+ */
+ static boolean canJoin6WithIPv4Group() {
+ return canJoin6WithIPv4Group0();
+ }
+
static InetSocketAddress checkAddress(SocketAddress sa) {
if (sa == null)
throw new NullPointerException();
@@ -291,7 +306,11 @@
// -- Socket operations --
- static native boolean isIPv6Available0();
+ private static native boolean isIPv6Available0();
+
+ private static native boolean canIPv6SocketJoinIPv4Group0();
+
+ private static native boolean canJoin6WithIPv4Group0();
static FileDescriptor socket(boolean stream) {
return socket(UNSPEC, stream);
--- a/jdk/src/share/classes/sun/nio/cs/ext/ExtendedCharsets.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/nio/cs/ext/ExtendedCharsets.java Mon Mar 21 16:57:18 2011 -0700
@@ -679,6 +679,14 @@
"1124"
});
+ charset("x-IBM1364", "IBM1364",
+ new String[] {
+ "cp1364",
+ "ibm1364",
+ "ibm-1364",
+ "1364"
+ });
+
charset("IBM273", "IBM273",
new String[] {
"cp273", // JDK historical
--- a/jdk/src/share/classes/sun/nio/fs/AbstractAclFileAttributeView.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/nio/fs/AbstractAclFileAttributeView.java Mon Mar 21 16:57:18 2011 -0700
@@ -57,8 +57,8 @@
setAcl((List<AclEntry>)value);
return;
}
- throw new UnsupportedOperationException("'" + name() + ":" +
- attribute + "' not supported");
+ throw new IllegalArgumentException("'" + name() + ":" +
+ attribute + "' not recognized");
}
@Override
@@ -81,6 +81,8 @@
owner = true;
continue;
}
+ throw new IllegalArgumentException("'" + name() + ":" +
+ attribute + "' not recognized");
}
Map<String,Object> result = new HashMap<>(2);
if (acl)
--- a/jdk/src/share/classes/sun/nio/fs/AbstractBasicFileAttributeView.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/nio/fs/AbstractBasicFileAttributeView.java Mon Mar 21 16:57:18 2011 -0700
@@ -46,6 +46,18 @@
private static final String IS_SYMBOLIC_LINK_NAME = "isSymbolicLink";
private static final String IS_OTHER_NAME = "isOther";
+ // the names of the basic attributes
+ static final Set<String> basicAttributeNames =
+ Util.newSet(SIZE_NAME,
+ CREATION_TIME_NAME,
+ LAST_ACCESS_TIME_NAME,
+ LAST_MODIFIED_TIME_NAME,
+ FILE_KEY_NAME,
+ IS_DIRECTORY_NAME,
+ IS_REGULAR_FILE_NAME,
+ IS_SYMBOLIC_LINK_NAME,
+ IS_OTHER_NAME);
+
protected AbstractBasicFileAttributeView() { }
@Override
@@ -69,24 +81,26 @@
setTimes(null, null, (FileTime)value);
return;
}
- throw new UnsupportedOperationException("'" + attribute +
- "' is unknown or read-only attribute");
+ throw new IllegalArgumentException("'" + name() + ":" +
+ attribute + "' not recognized");
}
/**
* Used to build a map of attribute name/values.
*/
static class AttributesBuilder {
- private Set<String> set = new HashSet<>();
+ private Set<String> names = new HashSet<>();
private Map<String,Object> map = new HashMap<>();
private boolean copyAll;
- private AttributesBuilder(String[] attributes) {
- for (String attribute: attributes) {
- if (attribute.equals("*")) {
+ private AttributesBuilder(Set<String> allowed, String[] requested) {
+ for (String name: requested) {
+ if (name.equals("*")) {
copyAll = true;
} else {
- set.add(attribute);
+ if (!allowed.contains(name))
+ throw new IllegalArgumentException("'" + name + "' not recognized");
+ names.add(name);
}
}
}
@@ -94,21 +108,19 @@
/**
* Creates builder to build up a map of the matching attributes
*/
- static AttributesBuilder create(String[] attributes) {
- return new AttributesBuilder(attributes);
+ static AttributesBuilder create(Set<String> allowed, String[] requested) {
+ return new AttributesBuilder(allowed, requested);
}
/**
* Returns true if the attribute should be returned in the map
*/
- boolean match(String attribute) {
- if (copyAll)
- return true;
- return set.contains(attribute);
+ boolean match(String name) {
+ return copyAll || names.contains(name);
}
- void add(String attribute, Object value) {
- map.put(attribute, value);
+ void add(String name, Object value) {
+ map.put(name, value);
}
/**
@@ -124,7 +136,7 @@
* Invoked by readAttributes or sub-classes to add all matching basic
* attributes to the builder
*/
- final void addBasicAttributesToBuilder(BasicFileAttributes attrs,
+ final void addRequestedBasicAttributes(BasicFileAttributes attrs,
AttributesBuilder builder)
{
if (builder.match(SIZE_NAME))
@@ -148,9 +160,12 @@
}
@Override
- public Map<String,Object> readAttributes(String[] attributes) throws IOException {
- AttributesBuilder builder = AttributesBuilder.create(attributes);
- addBasicAttributesToBuilder(readAttributes(), builder);
+ public Map<String,Object> readAttributes(String[] requested)
+ throws IOException
+ {
+ AttributesBuilder builder =
+ AttributesBuilder.create(basicAttributeNames, requested);
+ addRequestedBasicAttributes(readAttributes(), builder);
return builder.unmodifiableMap();
}
}
--- a/jdk/src/share/classes/sun/nio/fs/AbstractFileSystemProvider.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/nio/fs/AbstractFileSystemProvider.java Mon Mar 21 16:57:18 2011 -0700
@@ -29,7 +29,6 @@
import java.nio.file.spi.FileSystemProvider;
import java.io.IOException;
import java.util.Map;
-import java.util.Collections;
/**
* Base implementation class of FileSystemProvider
@@ -72,6 +71,8 @@
throws IOException
{
String[] s = split(attribute);
+ if (s[0].length() == 0)
+ throw new IllegalArgumentException(attribute);
DynamicFileAttributeView view = getFileAttributeView(file, s[0], options);
if (view == null)
throw new UnsupportedOperationException("View '" + s[0] + "' not available");
@@ -83,9 +84,11 @@
throws IOException
{
String[] s = split(attributes);
+ if (s[0].length() == 0)
+ throw new IllegalArgumentException(attributes);
DynamicFileAttributeView view = getFileAttributeView(file, s[0], options);
if (view == null)
- return Collections.emptyMap();
+ throw new UnsupportedOperationException("View '" + s[0] + "' not available");
return view.readAttributes(s[1].split(","));
}
--- a/jdk/src/share/classes/sun/nio/fs/AbstractUserDefinedFileAttributeView.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/nio/fs/AbstractUserDefinedFileAttributeView.java Mon Mar 21 16:57:18 2011 -0700
@@ -59,22 +59,6 @@
return "user";
}
- private Object getAttribute(String attribute) throws IOException {
- int size;
- try {
- size = size(attribute);
- } catch (IOException e) {
- // not found or some other I/O error
- if (list().contains(attribute))
- throw e;
- return null;
- }
-
- byte[] buf = new byte[size];
- int n = read(attribute, ByteBuffer.wrap(buf));
- return (n == size) ? buf : Arrays.copyOf(buf, n);
- }
-
@Override
public final void setAttribute(String attribute, Object value)
throws IOException
@@ -94,12 +78,13 @@
{
// names of attributes to return
List<String> names = new ArrayList<>();
-
for (String name: attributes) {
if (name.equals("*")) {
names = list();
break;
} else {
+ if (name.length() == 0)
+ throw new IllegalArgumentException();
names.add(name);
}
}
@@ -107,11 +92,12 @@
// read each value and return in map
Map<String,Object> result = new HashMap<>();
for (String name: names) {
- Object value = getAttribute(name);
- if (value != null)
- result.put(name, value);
+ int size = size(name);
+ byte[] buf = new byte[size];
+ int n = read(name, ByteBuffer.wrap(buf));
+ byte[] value = (n == size) ? buf : Arrays.copyOf(buf, n);
+ result.put(name, value);
}
-
return result;
}
}
--- a/jdk/src/share/classes/sun/nio/fs/AbstractWatchKey.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/nio/fs/AbstractWatchKey.java Mon Mar 21 16:57:18 2011 -0700
@@ -81,7 +81,8 @@
/**
* Return the original watchable (Path)
*/
- Path watchable() {
+ @Override
+ public Path watchable() {
return dir;
}
--- a/jdk/src/share/classes/sun/nio/fs/FileOwnerAttributeViewImpl.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/nio/fs/FileOwnerAttributeViewImpl.java Mon Mar 21 16:57:18 2011 -0700
@@ -63,10 +63,10 @@
{
if (attribute.equals(OWNER_NAME)) {
setOwner((UserPrincipal)value);
- return;
+ } else {
+ throw new IllegalArgumentException("'" + name() + ":" +
+ attribute + "' not recognized");
}
- throw new UnsupportedOperationException("'" + name() + ":" +
- attribute + "' not supported");
}
@Override
@@ -75,6 +75,9 @@
for (String attribute: attributes) {
if (attribute.equals("*") || attribute.equals(OWNER_NAME)) {
result.put(OWNER_NAME, getOwner());
+ } else {
+ throw new IllegalArgumentException("'" + name() + ":" +
+ attribute + "' not recognized");
}
}
return result;
--- a/jdk/src/share/classes/sun/nio/fs/Util.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/nio/fs/Util.java Mon Mar 21 16:57:18 2011 -0700
@@ -25,6 +25,8 @@
package sun.nio.fs;
+import java.util.*;
+
/**
* Utility methods
*/
@@ -54,6 +56,28 @@
}
result[n] = s.substring(last, s.length());
return result;
+ }
+ /**
+ * Returns a Set containing the given elements.
+ */
+ static <E> Set<E> newSet(E... elements) {
+ HashSet<E> set = new HashSet<>();
+ for (E e: elements) {
+ set.add(e);
+ }
+ return set;
+ }
+
+ /**
+ * Returns a Set containing all the elements of the given Set plus
+ * the given elements.
+ */
+ static <E> Set<E> newSet(Set<E> other, E... elements) {
+ HashSet<E> set = new HashSet<>(other);
+ for (E e: elements) {
+ set.add(e);
+ }
+ return set;
}
}
--- a/jdk/src/share/classes/sun/security/pkcs11/P11Key.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/security/pkcs11/P11Key.java Mon Mar 21 16:57:18 2011 -0700
@@ -999,18 +999,34 @@
new CK_ATTRIBUTE(CKA_EC_PARAMS),
};
fetchAttributes(attributes);
+
try {
params = P11ECKeyFactory.decodeParameters
(attributes[1].getByteArray());
- DerValue wECPoint = new DerValue(attributes[0].getByteArray());
- if (wECPoint.getTag() != DerValue.tag_OctetString)
- throw new IOException("Unexpected tag: " +
- wECPoint.getTag());
- params = P11ECKeyFactory.decodeParameters
- (attributes[1].getByteArray());
- w = P11ECKeyFactory.decodePoint
- (wECPoint.getDataBytes(), params.getCurve());
+
+ /*
+ * An uncompressed EC point may be in either of two formats.
+ * First try the OCTET STRING encoding:
+ * 04 <length> 04 <X-coordinate> <Y-coordinate>
+ *
+ * Otherwise try the raw encoding:
+ * 04 <X-coordinate> <Y-coordinate>
+ */
+ byte[] ecKey = attributes[0].getByteArray();
+ try {
+ DerValue wECPoint = new DerValue(ecKey);
+ if (wECPoint.getTag() != DerValue.tag_OctetString)
+ throw new IOException("Unexpected tag: " +
+ wECPoint.getTag());
+
+ w = P11ECKeyFactory.decodePoint
+ (wECPoint.getDataBytes(), params.getCurve());
+
+ } catch (IOException e) {
+ // Failover
+ w = P11ECKeyFactory.decodePoint(ecKey, params.getCurve());
+ }
} catch (Exception e) {
throw new RuntimeException("Could not parse key values", e);
--- a/jdk/src/share/classes/sun/security/provider/certpath/AdaptableX509CertSelector.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/security/provider/certpath/AdaptableX509CertSelector.java Mon Mar 21 16:57:18 2011 -0700
@@ -46,10 +46,16 @@
*/
class AdaptableX509CertSelector extends X509CertSelector {
// The start date of a validity period.
- private Date startDate = null;
+ private Date startDate;
// The end date of a validity period.
- private Date endDate = null;
+ private Date endDate;
+
+ // Is subject key identifier sensitive?
+ private boolean isSKIDSensitive = false;
+
+ // Is serial number sensitive?
+ private boolean isSNSensitive = false;
AdaptableX509CertSelector() {
super();
@@ -97,15 +103,24 @@
if (akidext != null) {
KeyIdentifier akid = (KeyIdentifier)akidext.get(akidext.KEY_ID);
if (akid != null) {
- DerOutputStream derout = new DerOutputStream();
- derout.putOctetString(akid.getIdentifier());
- super.setSubjectKeyIdentifier(derout.toByteArray());
+ // Do not override the previous setting for initial selection.
+ if (isSKIDSensitive || getSubjectKeyIdentifier() == null) {
+ DerOutputStream derout = new DerOutputStream();
+ derout.putOctetString(akid.getIdentifier());
+ super.setSubjectKeyIdentifier(derout.toByteArray());
+
+ isSKIDSensitive = true;
+ }
}
SerialNumber asn =
(SerialNumber)akidext.get(akidext.SERIAL_NUMBER);
if (asn != null) {
- super.setSerialNumber(asn.getNumber());
+ // Do not override the previous setting for initial selection.
+ if (isSNSensitive || getSerialNumber() == null) {
+ super.setSerialNumber(asn.getNumber());
+ isSNSensitive = true;
+ }
}
// the subject criterion should be set by the caller.
@@ -148,11 +163,25 @@
}
}
- if (version < 3 || xcert.getExtensionValue("2.5.29.14") == null) {
- // If no SubjectKeyIdentifier extension, don't bother to check it.
+ // If no SubjectKeyIdentifier extension, don't bother to check it.
+ if (isSKIDSensitive &&
+ (version < 3 || xcert.getExtensionValue("2.5.29.14") == null)) {
setSubjectKeyIdentifier(null);
}
+ // In practice, a CA may replace its root certificate and require that
+ // the existing certificate is still valid, even if the AKID extension
+ // does not match the replacement root certificate fields.
+ //
+ // Conservatively, we only support the replacement for version 1 and
+ // version 2 certificate. As for version 2, the certificate extension
+ // may contain sensitive information (for example, policies), the
+ // AKID need to be respected to seek the exact certificate in case
+ // of key or certificate abuse.
+ if (isSNSensitive && version < 3) {
+ setSerialNumber(null);
+ }
+
return super.match(cert);
}
--- a/jdk/src/share/classes/sun/security/provider/certpath/ForwardBuilder.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/security/provider/certpath/ForwardBuilder.java Mon Mar 21 16:57:18 2011 -0700
@@ -243,12 +243,6 @@
caTargetSelector.setPolicy(getMatchingPolicies());
}
- /*
- * Require CA certs with a pathLenConstraint that allows
- * at least as many CA certs that have already been traversed
- */
- caTargetSelector.setBasicConstraints(currentState.traversedCACerts);
-
sel = caTargetSelector;
} else {
@@ -283,12 +277,6 @@
(caSelector, currentState.subjectNamesTraversed);
/*
- * Require CA certs with a pathLenConstraint that allows
- * at least as many CA certs that have already been traversed
- */
- caSelector.setBasicConstraints(currentState.traversedCACerts);
-
- /*
* Facilitate certification path construction with authority
* key identifier and subject key identifier.
*/
@@ -305,6 +293,14 @@
sel = caSelector;
}
+ /*
+ * For compatibility, conservatively, we don't check the path
+ * length constraint of trusted anchors. Please don't set the
+ * basic constraints criterion unless the trusted certificate
+ * matching is completed.
+ */
+ sel.setBasicConstraints(-1);
+
for (X509Certificate trustedCert : trustedCerts) {
if (sel.match(trustedCert)) {
if (debug != null) {
@@ -324,6 +320,12 @@
sel.setCertificateValid(date);
/*
+ * Require CA certs with a pathLenConstraint that allows
+ * at least as many CA certs that have already been traversed
+ */
+ sel.setBasicConstraints(currentState.traversedCACerts);
+
+ /*
* If we have already traversed as many CA certs as the maxPathLength
* will allow us to, then we don't bother looking through these
* certificate pairs. If maxPathLength has a value of -1, this
--- a/jdk/src/share/classes/sun/security/ssl/ClientHandshaker.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/security/ssl/ClientHandshaker.java Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -377,8 +377,9 @@
ProtocolVersion mesgVersion = mesg.protocolVersion;
if (!isNegotiable(mesgVersion)) {
throw new SSLHandshakeException(
- "Server chose unsupported or disabled protocol: " +
- mesgVersion);
+ "Server chose " + mesgVersion +
+ ", but that protocol version is not enabled or not supported " +
+ "by the client.");
}
handshakeHash.protocolDetermined(mesgVersion);
--- a/jdk/src/share/classes/sun/security/ssl/SunJSSE.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/classes/sun/security/ssl/SunJSSE.java Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -195,6 +195,8 @@
"sun.security.ssl.KeyManagerFactoryImpl$SunX509");
put("KeyManagerFactory.NewSunX509",
"sun.security.ssl.KeyManagerFactoryImpl$X509");
+ put("Alg.Alias.KeyManagerFactory.PKIX", "NewSunX509");
+
put("TrustManagerFactory.SunX509",
"sun.security.ssl.TrustManagerFactoryImpl$SimpleFactory");
put("TrustManagerFactory.PKIX",
--- a/jdk/src/share/lib/security/java.security Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/lib/security/java.security Mon Mar 21 16:57:18 2011 -0700
@@ -123,7 +123,7 @@
# passed to checkPackageAccess unless the
# corresponding RuntimePermission ("accessClassInPackage."+package) has
# been granted.
-package.access=sun.,com.sun.imageio.
+package.access=sun.,com.sun.xml.internal.ws.,com.sun.xml.internal.bind.,com.sun.imageio.
#
# List of comma-separated packages that start with or equal this string
--- a/jdk/src/share/lib/security/java.security-solaris Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/lib/security/java.security-solaris Mon Mar 21 16:57:18 2011 -0700
@@ -124,7 +124,7 @@
# passed to checkPackageAccess unless the
# corresponding RuntimePermission ("accessClassInPackage."+package) has
# been granted.
-package.access=sun.,com.sun.imageio.
+package.access=sun.,com.sun.xml.internal.ws.,com.sun.xml.internal.bind.,com.sun.imageio.
#
# List of comma-separated packages that start with or equal this string
--- a/jdk/src/share/lib/security/java.security-windows Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/lib/security/java.security-windows Mon Mar 21 16:57:18 2011 -0700
@@ -124,7 +124,7 @@
# passed to checkPackageAccess unless the
# corresponding RuntimePermission ("accessClassInPackage."+package) has
# been granted.
-package.access=sun.,com.sun.imageio.
+package.access=sun.,com.sun.xml.internal.ws.,com.sun.xml.internal.bind.,com.sun.imageio.
#
# List of comma-separated packages that start with or equal this string
--- a/jdk/src/share/native/com/sun/java/util/jar/pack/unpack.cpp Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/native/com/sun/java/util/jar/pack/unpack.cpp Mon Mar 21 16:57:18 2011 -0700
@@ -489,7 +489,6 @@
// Call malloc. Try to combine small blocks and free much later.
void* unpacker::alloc_heap(size_t size, bool smallOK, bool temp) {
- CHECK_0;
if (!smallOK || size > SMALL) {
void* res = must_malloc((int)size);
(temp ? &tmallocs : &mallocs)->add(res);
@@ -2560,6 +2559,10 @@
int i;
int prevBII = -1;
int prevBCI = -1;
+ if (body == NULL) {
+ abort("putlayout: unexpected NULL for body");
+ return;
+ }
for (i = 0; body[i] != null; i++) {
band& b = *body[i];
byte le_kind = b.le_kind;
@@ -4767,7 +4770,9 @@
}
char *tname = tempnam(tmpdir,"#upkg");
+ if (tname == NULL) return;
sprintf(log_file_name, "%s", tname);
+ ::free(tname);
if ((errstrm = fopen(log_file_name, "a+")) != NULL) {
log_file = errstrm_name = saveStr(log_file_name);
return ;
--- a/jdk/src/share/native/com/sun/media/sound/SoundDefs.h Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/native/com/sun/media/sound/SoundDefs.h Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -39,6 +39,8 @@
#define X_IA64 4
#define X_AMD64 5
#define X_ZERO 6
+#define X_ARM 7
+#define X_PPC 8
// **********************************
// Make sure you set X_PLATFORM and X_ARCH defines correctly.
--- a/jdk/src/share/native/java/lang/fdlibm/include/fdlibm.h Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/native/java/lang/fdlibm/include/fdlibm.h Mon Mar 21 16:57:18 2011 -0700
@@ -1,6 +1,6 @@
/*
- * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -28,8 +28,8 @@
#ifdef __NEWVALID /* special setup for Sun test regime */
#if defined(i386) || defined(i486) || \
- defined(intel) || defined(x86) || \
- defined(i86pc) || defined(_M_IA64) || defined(ia64)
+ defined(intel) || defined(x86) || defined(arm) || \
+ defined(i86pc) || defined(_M_IA64) || defined(ia64)
#define _LITTLE_ENDIAN
#endif
#endif
--- a/jdk/src/share/sample/nio/file/WatchDir.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/share/sample/nio/file/WatchDir.java Mon Mar 21 16:57:18 2011 -0700
@@ -33,8 +33,7 @@
import static java.nio.file.StandardWatchEventKind.*;
import static java.nio.file.LinkOption.*;
import java.nio.file.attribute.*;
-import java.io.*;
-import java.util.*;
+import java.io.IOException;
/**
* Example to watch a directory (or tree) for changes to files.
@@ -43,9 +42,9 @@
public class WatchDir {
private final WatchService watcher;
- private final Map<WatchKey,Path> keys;
private final boolean recursive;
private boolean trace = false;
+ private int count;
@SuppressWarnings("unchecked")
static <T> WatchEvent<T> cast(WatchEvent<?> event) {
@@ -57,17 +56,9 @@
*/
private void register(Path dir) throws IOException {
WatchKey key = dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
- if (trace) {
- Path prev = keys.get(key);
- if (prev == null) {
- System.out.format("register: %s\n", dir);
- } else {
- if (!dir.equals(prev)) {
- System.out.format("update: %s -> %s\n", prev, dir);
- }
- }
- }
- keys.put(key, dir);
+ count++;
+ if (trace)
+ System.out.format("register: %s\n", dir);
}
/**
@@ -92,7 +83,6 @@
*/
WatchDir(Path dir, boolean recursive) throws IOException {
this.watcher = FileSystems.getDefault().newWatchService();
- this.keys = new HashMap<WatchKey,Path>();
this.recursive = recursive;
if (recursive) {
@@ -121,12 +111,6 @@
return;
}
- Path dir = keys.get(key);
- if (dir == null) {
- System.err.println("WatchKey not recognized!!");
- continue;
- }
-
for (WatchEvent<?> event: key.pollEvents()) {
WatchEvent.Kind kind = event.kind();
@@ -138,7 +122,7 @@
// Context for directory entry event is the file name of entry
WatchEvent<Path> ev = cast(event);
Path name = ev.context();
- Path child = dir.resolve(name);
+ Path child = ((Path)key.watchable()).resolve(name);
// print out event
System.out.format("%s: %s\n", event.kind().name(), child);
@@ -156,15 +140,13 @@
}
}
- // reset key and remove from set if directory no longer accessible
+ // reset key
boolean valid = key.reset();
if (!valid) {
- keys.remove(key);
-
- // all directories are inaccessible
- if (keys.isEmpty()) {
+ // directory no longer accessible
+ count--;
+ if (count == 0)
break;
- }
}
}
}
--- a/jdk/src/solaris/bin/ergo.c Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/solaris/bin/ergo.c Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1998, 2007, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -67,6 +67,35 @@
}
}
+#ifdef USE_GENERIC_ERGO
+/* Ask the OS how many processors there are. */
+static unsigned long
+physical_processors(void) {
+ const unsigned long sys_processors = sysconf(_SC_NPROCESSORS_CONF);
+ JLI_TraceLauncher("sysconf(_SC_NPROCESSORS_CONF): %lu\n", sys_processors);
+ return sys_processors;
+}
+
+jboolean
+ServerClassMachineImpl(void) {
+ jboolean result = JNI_FALSE;
+ /* How big is a server class machine? */
+ const unsigned long server_processors = 2UL;
+ const uint64_t server_memory = 2UL * GB;
+ const uint64_t actual_memory = physical_memory();
+
+ /* Is this a server class machine? */
+ if (actual_memory >= server_memory) {
+ const unsigned long actual_processors = physical_processors();
+ if (actual_processors >= server_processors) {
+ result = JNI_TRUE;
+ }
+ }
+ JLI_TraceLauncher("unix_" LIBARCHNAME "_ServerClassMachine: %s\n",
+ (result == JNI_TRUE ? "JNI_TRUE" : "JNI_FALSE"));
+ return result;
+}
+#endif
/* Compute physical memory by asking the OS */
uint64_t
--- a/jdk/src/solaris/bin/ergo_sparc.c Mon Mar 21 16:55:14 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 1998, 2007, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-#include "ergo.h"
-
-
-/* Methods for solaris-sparc and linux-sparc: these are easy. */
-
-/* Ask the OS how many processors there are. */
-static unsigned long
-physical_processors(void) {
- const unsigned long sys_processors = sysconf(_SC_NPROCESSORS_CONF);
-
- JLI_TraceLauncher("sysconf(_SC_NPROCESSORS_CONF): %lu\n", sys_processors);
- return sys_processors;
-}
-
-/* The sparc version of the "server-class" predicate. */
-jboolean
-ServerClassMachineImpl(void) {
- jboolean result = JNI_FALSE;
- /* How big is a server class machine? */
- const unsigned long server_processors = 2UL;
- const uint64_t server_memory = 2UL * GB;
- const uint64_t actual_memory = physical_memory();
-
- /* Is this a server class machine? */
- if (actual_memory >= server_memory) {
- const unsigned long actual_processors = physical_processors();
- if (actual_processors >= server_processors) {
- result = JNI_TRUE;
- }
- }
- JLI_TraceLauncher("unix_" LIBARCHNAME "_ServerClassMachine: %s\n",
- (result == JNI_TRUE ? "JNI_TRUE" : "JNI_FALSE"));
- return result;
-}
--- a/jdk/src/solaris/bin/ergo_zero.c Mon Mar 21 16:55:14 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 1998, 2007, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-#include "ergo.h"
-
-
-/* Methods for solaris-sparc and linux-sparc: these are easy. */
-
-/* Ask the OS how many processors there are. */
-static unsigned long
-physical_processors(void) {
- const unsigned long sys_processors = sysconf(_SC_NPROCESSORS_CONF);
-
- JLI_TraceLauncher("sysconf(_SC_NPROCESSORS_CONF): %lu\n", sys_processors);
- return sys_processors;
-}
-
-/* The sparc version of the "server-class" predicate. */
-jboolean
-ServerClassMachineImpl(void) {
- jboolean result = JNI_FALSE;
- /* How big is a server class machine? */
- const unsigned long server_processors = 2UL;
- const uint64_t server_memory = 2UL * GB;
- const uint64_t actual_memory = physical_memory();
-
- /* Is this a server class machine? */
- if (actual_memory >= server_memory) {
- const unsigned long actual_processors = physical_processors();
- if (actual_processors >= server_processors) {
- result = JNI_TRUE;
- }
- }
- JLI_TraceLauncher("unix_" LIBARCHNAME "_ServerClassMachine: %s\n",
- (result == JNI_TRUE ? "JNI_TRUE" : "JNI_FALSE"));
- return result;
-}
--- a/jdk/src/solaris/classes/sun/nio/fs/LinuxDosFileAttributeView.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/solaris/classes/sun/nio/fs/LinuxDosFileAttributeView.java Mon Mar 21 16:57:18 2011 -0700
@@ -27,6 +27,7 @@
import java.nio.file.attribute.*;
import java.util.Map;
+import java.util.Set;
import java.io.IOException;
import sun.misc.Unsafe;
@@ -57,6 +58,10 @@
private static final int DOS_XATTR_SYSTEM = 0x04;
private static final int DOS_XATTR_ARCHIVE = 0x20;
+ // the names of the DOS attributes (includes basic)
+ private static final Set<String> dosAttributeNames =
+ Util.newSet(basicAttributeNames, READONLY_NAME, ARCHIVE_NAME, SYSTEM_NAME, HIDDEN_NAME);
+
LinuxDosFileAttributeView(UnixPath file, boolean followLinks) {
super(file, followLinks);
}
@@ -93,9 +98,10 @@
public Map<String,Object> readAttributes(String[] attributes)
throws IOException
{
- AttributesBuilder builder = AttributesBuilder.create(attributes);
+ AttributesBuilder builder =
+ AttributesBuilder.create(dosAttributeNames, attributes);
DosFileAttributes attrs = readAttributes();
- addBasicAttributesToBuilder(attrs, builder);
+ addRequestedBasicAttributes(attrs, builder);
if (builder.match(READONLY_NAME))
builder.add(READONLY_NAME, attrs.isReadOnly());
if (builder.match(ARCHIVE_NAME))
--- a/jdk/src/solaris/classes/sun/nio/fs/LinuxFileSystem.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/solaris/classes/sun/nio/fs/LinuxFileSystem.java Mon Mar 21 16:57:18 2011 -0700
@@ -28,8 +28,6 @@
import java.nio.file.*;
import java.io.IOException;
import java.util.*;
-import java.security.AccessController;
-import sun.security.action.GetPropertyAction;
import static sun.nio.fs.LinuxNativeDispatcher.*;
/**
@@ -37,42 +35,16 @@
*/
class LinuxFileSystem extends UnixFileSystem {
- private final boolean hasInotify;
-
LinuxFileSystem(UnixFileSystemProvider provider, String dir) {
super(provider, dir);
-
- // assume X.Y[-Z] format
- String osversion = AccessController
- .doPrivileged(new GetPropertyAction("os.version"));
- String[] vers = Util.split(osversion, '.');
- assert vers.length >= 2;
-
- int majorVersion = Integer.parseInt(vers[0]);
- int minorVersion = Integer.parseInt(vers[1]);
- int microVersion = 0;
- if (vers.length > 2) {
- String[] microVers = Util.split(vers[2], '-');
- microVersion = (microVers.length > 0) ?
- Integer.parseInt(microVers[0]) : 0;
- }
-
- // inotify available since 2.6.13
- this.hasInotify = ((majorVersion > 2) ||
- (majorVersion == 2 && minorVersion > 6) ||
- ((majorVersion == 2) && (minorVersion == 6) && (microVersion >= 13)));
}
@Override
public WatchService newWatchService()
throws IOException
{
- if (hasInotify) {
- return new LinuxWatchService(this);
- } else {
- // use polling implementation on older kernels
- return new PollingWatchService();
- }
+ // assume 2.6.13 or newer
+ return new LinuxWatchService(this);
}
--- a/jdk/src/solaris/classes/sun/nio/fs/UnixFileAttributeViews.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/solaris/classes/sun/nio/fs/UnixFileAttributeViews.java Mon Mar 21 16:57:18 2011 -0700
@@ -123,6 +123,10 @@
private static final String OWNER_NAME = "owner";
private static final String GROUP_NAME = "group";
+ // the names of the posix attributes (incudes basic)
+ static final Set<String> posixAttributeNames =
+ Util.newSet(basicAttributeNames, PERMISSIONS_NAME, OWNER_NAME, GROUP_NAME);
+
Posix(UnixPath file, boolean followLinks) {
super(file, followLinks);
}
@@ -172,9 +176,10 @@
* Invoked by readAttributes or sub-classes to add all matching posix
* attributes to the builder
*/
- final void addPosixAttributesToBuilder(PosixFileAttributes attrs,
+ final void addRequestedPosixAttributes(PosixFileAttributes attrs,
AttributesBuilder builder)
{
+ addRequestedBasicAttributes(attrs, builder);
if (builder.match(PERMISSIONS_NAME))
builder.add(PERMISSIONS_NAME, attrs.permissions());
if (builder.match(OWNER_NAME))
@@ -184,13 +189,13 @@
}
@Override
- public Map<String,Object> readAttributes(String[] attributes)
+ public Map<String,Object> readAttributes(String[] requested)
throws IOException
{
- AttributesBuilder builder = AttributesBuilder.create(attributes);
+ AttributesBuilder builder =
+ AttributesBuilder.create(posixAttributeNames, requested);
PosixFileAttributes attrs = readAttributes();
- addBasicAttributesToBuilder(attrs, builder);
- addPosixAttributesToBuilder(attrs, builder);
+ addRequestedPosixAttributes(attrs, builder);
return builder.unmodifiableMap();
}
@@ -287,6 +292,12 @@
private static final String GID_NAME = "gid";
private static final String CTIME_NAME = "ctime";
+ // the names of the unix attributes (including posix)
+ static final Set<String> unixAttributeNames =
+ Util.newSet(posixAttributeNames,
+ MODE_NAME, INO_NAME, DEV_NAME, RDEV_NAME,
+ NLINK_NAME, UID_NAME, GID_NAME, CTIME_NAME);
+
Unix(UnixPath file, boolean followLinks) {
super(file, followLinks);
}
@@ -316,13 +327,13 @@
}
@Override
- public Map<String,Object> readAttributes(String[] attributes)
+ public Map<String,Object> readAttributes(String[] requested)
throws IOException
{
- AttributesBuilder builder = AttributesBuilder.create(attributes);
+ AttributesBuilder builder =
+ AttributesBuilder.create(unixAttributeNames, requested);
UnixFileAttributes attrs = readAttributes();
- addBasicAttributesToBuilder(attrs, builder);
- addPosixAttributesToBuilder(attrs, builder);
+ addRequestedPosixAttributes(attrs, builder);
if (builder.match(MODE_NAME))
builder.add(MODE_NAME, attrs.mode());
if (builder.match(INO_NAME))
--- a/jdk/src/solaris/classes/sun/nio/fs/UnixPath.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/solaris/classes/sun/nio/fs/UnixPath.java Mon Mar 21 16:57:18 2011 -0700
@@ -606,7 +606,9 @@
@Override
public boolean startsWith(Path other) {
- UnixPath that = toUnixPath(other);
+ if (!(Objects.requireNonNull(other) instanceof UnixPath))
+ return false;
+ UnixPath that = (UnixPath)other;
// other path is longer
if (that.path.length > path.length)
@@ -655,7 +657,9 @@
@Override
public boolean endsWith(Path other) {
- UnixPath that = toUnixPath(other);
+ if (!(Objects.requireNonNull(other) instanceof UnixPath))
+ return false;
+ UnixPath that = (UnixPath)other;
int thisLen = path.length;
int thatLen = that.path.length;
--- a/jdk/src/solaris/native/java/net/Inet4AddressImpl.c Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/solaris/native/java/net/Inet4AddressImpl.c Mon Mar 21 16:57:18 2011 -0700
@@ -60,7 +60,7 @@
char hostname[MAXHOSTNAMELEN+1];
hostname[0] = '\0';
- if (JVM_GetHostName(hostname, MAXHOSTNAMELEN)) {
+ if (JVM_GetHostName(hostname, sizeof(hostname))) {
/* Something went wrong, maybe networking is not setup? */
strcpy(hostname, "localhost");
} else {
@@ -83,6 +83,9 @@
char *buf2[HENT_BUF_SIZE/(sizeof (char *))];
int h_error=0;
+ // ensure null-terminated
+ hostname[MAXHOSTNAMELEN] = '\0';
+
#ifdef __GLIBC__
gethostbyname_r(hostname, &res, (char*)buf, sizeof(buf), &hp, &h_error);
#else
--- a/jdk/src/solaris/native/java/net/Inet6AddressImpl.c Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/solaris/native/java/net/Inet6AddressImpl.c Mon Mar 21 16:57:18 2011 -0700
@@ -64,10 +64,12 @@
char hostname[NI_MAXHOST+1];
hostname[0] = '\0';
- if (JVM_GetHostName(hostname, MAXHOSTNAMELEN)) {
+ if (JVM_GetHostName(hostname, sizeof(hostname))) {
/* Something went wrong, maybe networking is not setup? */
strcpy(hostname, "localhost");
} else {
+ // ensure null-terminated
+ hostname[NI_MAXHOST] = '\0';
#ifdef __linux__
/* On Linux gethostname() says "host.domain.sun.com". On
* Solaris gethostname() says "host", so extra work is needed.
--- a/jdk/src/solaris/native/sun/nio/ch/Net.c Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/solaris/native/sun/nio/ch/Net.c Mon Mar 21 16:57:18 2011 -0700
@@ -154,6 +154,22 @@
return (ipv6_available()) ? JNI_TRUE : JNI_FALSE;
}
+JNIEXPORT jboolean JNICALL
+Java_sun_nio_ch_Net_canIPv6SocketJoinIPv4Group0(JNIEnv* env, jclass cl)
+{
+ return JNI_TRUE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_sun_nio_ch_Net_canJoin6WithIPv4Group0(JNIEnv* env, jclass cl)
+{
+#ifdef __solaris__
+ return JNI_TRUE;
+#else
+ return JNI_FALSE;
+#endif
+}
+
JNIEXPORT int JNICALL
Java_sun_nio_ch_Net_socket0(JNIEnv *env, jclass cl, jboolean preferIPv6,
jboolean stream, jboolean reuse)
--- a/jdk/src/windows/classes/sun/nio/fs/WindowsFileAttributeViews.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/windows/classes/sun/nio/fs/WindowsFileAttributeViews.java Mon Mar 21 16:57:18 2011 -0700
@@ -157,6 +157,11 @@
private static final String HIDDEN_NAME = "hidden";
private static final String ATTRIBUTES_NAME = "attributes";
+ // the names of the DOS attribtues (includes basic)
+ static final Set<String> dosAttributeNames =
+ Util.newSet(basicAttributeNames,
+ READONLY_NAME, ARCHIVE_NAME, SYSTEM_NAME, HIDDEN_NAME, ATTRIBUTES_NAME);
+
Dos(WindowsPath file, boolean followLinks) {
super(file, followLinks);
}
@@ -193,9 +198,10 @@
public Map<String,Object> readAttributes(String[] attributes)
throws IOException
{
- AttributesBuilder builder = AttributesBuilder.create(attributes);
+ AttributesBuilder builder =
+ AttributesBuilder.create(dosAttributeNames, attributes);
WindowsFileAttributes attrs = readAttributes();
- addBasicAttributesToBuilder(attrs, builder);
+ addRequestedBasicAttributes(attrs, builder);
if (builder.match(READONLY_NAME))
builder.add(READONLY_NAME, attrs.isReadOnly());
if (builder.match(ARCHIVE_NAME))
--- a/jdk/src/windows/classes/sun/nio/fs/WindowsPath.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/windows/classes/sun/nio/fs/WindowsPath.java Mon Mar 21 16:57:18 2011 -0700
@@ -646,7 +646,9 @@
@Override
public boolean startsWith(Path obj) {
- WindowsPath other = toWindowsPath(obj);
+ if (!(Objects.requireNonNull(obj) instanceof WindowsPath))
+ return false;
+ WindowsPath other = (WindowsPath)obj;
// if this path has a root component the given path's root must match
if (!this.root.equalsIgnoreCase(other.root)) {
@@ -675,7 +677,9 @@
@Override
public boolean endsWith(Path obj) {
- WindowsPath other = toWindowsPath(obj);
+ if (!(Objects.requireNonNull(obj) instanceof WindowsPath))
+ return false;
+ WindowsPath other = (WindowsPath)obj;
// other path is longer
if (other.path.length() > this.path.length()) {
--- a/jdk/src/windows/native/sun/nio/ch/Net.c Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/windows/native/sun/nio/ch/Net.c Mon Mar 21 16:57:18 2011 -0700
@@ -100,6 +100,18 @@
return JNI_FALSE;
}
+JNIEXPORT jboolean JNICALL
+Java_sun_nio_ch_Net_canIPv6SocketJoinIPv4Group0(JNIEnv* env, jclass cl)
+{
+ return JNI_FALSE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_sun_nio_ch_Net_canJoin6WithIPv4Group0(JNIEnv* env, jclass cl)
+{
+ return JNI_FALSE;
+}
+
JNIEXPORT jint JNICALL
Java_sun_nio_ch_Net_socket0(JNIEnv *env, jclass cl, jboolean preferIPv6,
jboolean stream, jboolean reuse)
--- a/jdk/src/windows/native/sun/security/krb5/NativeCreds.c Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/windows/native/sun/security/krb5/NativeCreds.c Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2009, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -1032,12 +1032,12 @@
// XXX Cannot use %02.2ld, because the leading 0 is ignored for integers.
// So, print them to strings, and then print them to the master string with a
// format pattern that makes it two digits and prefix with a 0 if necessary.
- swprintf( (wchar_t *)month, L"%2.2d", systemTime.wMonth);
- swprintf( (wchar_t *)day, L"%2.2d", systemTime.wDay);
- swprintf( (wchar_t *)hour, L"%2.2d", systemTime.wHour);
- swprintf( (wchar_t *)minute, L"%2.2d", systemTime.wMinute);
- swprintf( (wchar_t *)second, L"%2.2d", systemTime.wSecond);
- swprintf( (wchar_t *)timeString,
+ swprintf( (wchar_t *)month, 3, L"%2.2d", systemTime.wMonth);
+ swprintf( (wchar_t *)day, 3, L"%2.2d", systemTime.wDay);
+ swprintf( (wchar_t *)hour, 3, L"%2.2d", systemTime.wHour);
+ swprintf( (wchar_t *)minute, 3, L"%2.2d", systemTime.wMinute);
+ swprintf( (wchar_t *)second, 3, L"%2.2d", systemTime.wSecond);
+ swprintf( (wchar_t *)timeString, 16,
L"%ld%02.2s%02.2s%02.2s%02.2s%02.2sZ",
systemTime.wYear,
month,
--- a/jdk/src/windows/native/sun/tools/attach/WindowsVirtualMachine.c Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/src/windows/native/sun/tools/attach/WindowsVirtualMachine.c Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -173,24 +173,45 @@
JNIEXPORT jlong JNICALL Java_sun_tools_attach_WindowsVirtualMachine_openProcess
(JNIEnv *env, jclass cls, jint pid)
{
- HANDLE hProcess;
+ HANDLE hProcess = NULL;
- /*
- * Attempt to open process. If it fails then we try to enable the
- * SE_DEBUG_NAME privilege and retry.
- */
- hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, (DWORD)pid);
- if (hProcess == NULL && GetLastError() == ERROR_ACCESS_DENIED) {
- hProcess = doPrivilegedOpenProcess(PROCESS_ALL_ACCESS, FALSE, (DWORD)pid);
+ if (pid == (jint) GetCurrentProcessId()) {
+ /* process is attaching to itself; get a pseudo handle instead */
+ hProcess = GetCurrentProcess();
+ /* duplicate the pseudo handle so it can be used in more contexts */
+ if (DuplicateHandle(hProcess, hProcess, hProcess, &hProcess,
+ PROCESS_ALL_ACCESS, FALSE, 0) == 0) {
+ /*
+ * Could not duplicate the handle which isn't a good sign,
+ * but we'll try again with OpenProcess() below.
+ */
+ hProcess = NULL;
+ }
}
if (hProcess == NULL) {
- if (GetLastError() == ERROR_INVALID_PARAMETER) {
- JNU_ThrowIOException(env, "no such process");
- } else {
- JNU_ThrowIOExceptionWithLastError(env, "OpenProcess failed");
+ /*
+ * Attempt to open process. If it fails then we try to enable the
+ * SE_DEBUG_NAME privilege and retry.
+ */
+ hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, (DWORD)pid);
+ if (hProcess == NULL && GetLastError() == ERROR_ACCESS_DENIED) {
+ hProcess = doPrivilegedOpenProcess(PROCESS_ALL_ACCESS, FALSE,
+ (DWORD)pid);
}
- return (jlong)0;
+
+ if (hProcess == NULL) {
+ if (GetLastError() == ERROR_INVALID_PARAMETER) {
+ JNU_ThrowIOException(env, "no such process");
+ } else {
+ char err_mesg[255];
+ /* include the last error in the default detail message */
+ sprintf(err_mesg, "OpenProcess(pid=%d) failed; LastError=0x%x",
+ (int)pid, (int)GetLastError());
+ JNU_ThrowIOExceptionWithLastError(env, err_mesg);
+ }
+ return (jlong)0;
+ }
}
/*
--- a/jdk/test/Makefile Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/test/Makefile Mon Mar 21 16:57:18 2011 -0700
@@ -399,12 +399,12 @@
endef
# Running batches of tests with or without samevm
define RunSamevmBatch
-$(ECHO) "Running tests in samevm mode: $(call TestDirs, $?)"
-$(MAKE) TESTDIRS="$(call TestDirs, $?)" USE_JTREG_SAMEVM=true UNIQUE_DIR=$@ jtreg_tests
+$(ECHO) "Running tests in samevm mode: $?"
+$(MAKE) TESTDIRS="$?" USE_JTREG_SAMEVM=true UNIQUE_DIR=$@ jtreg_tests
endef
define RunOthervmBatch
-$(ECHO) "Running tests in othervm mode: $(call TestDirs, $?)"
-$(MAKE) TESTDIRS="$(call TestDirs, $?)" USE_JTREG_SAMEVM=false UNIQUE_DIR=$@ jtreg_tests
+$(ECHO) "Running tests in othervm mode: $?"
+$(MAKE) TESTDIRS="$?" USE_JTREG_SAMEVM=false UNIQUE_DIR=$@ jtreg_tests
endef
define SummaryInfo
$(ECHO) "########################################################"
@@ -420,27 +420,29 @@
# Stable othervm testruns (minus items from PROBLEM_LIST)
# Using samevm has problems, and doesn't help performance as much as others.
JDK_ALL_TARGETS += jdk_awt
-jdk_awt: com/sun/awt java/awt sun/awt
+jdk_awt: $(call TestDirs, com/sun/awt java/awt sun/awt)
$(call RunOthervmBatch)
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_beans1
-jdk_beans1: java/beans/beancontext java/beans/PropertyChangeSupport \
+jdk_beans1: $(call TestDirs, \
+ java/beans/beancontext java/beans/PropertyChangeSupport \
java/beans/Introspector java/beans/Performance \
- java/beans/VetoableChangeSupport java/beans/Statement
+ java/beans/VetoableChangeSupport java/beans/Statement)
$(call RunSamevmBatch)
# Stable othervm testruns (minus items from PROBLEM_LIST)
# Using samevm has serious problems with these tests
JDK_ALL_TARGETS += jdk_beans2
-jdk_beans2: java/beans/Beans java/beans/EventHandler java/beans/XMLDecoder \
- java/beans/PropertyEditor
+jdk_beans2: $(call TestDirs, \
+ java/beans/Beans java/beans/EventHandler java/beans/XMLDecoder \
+ java/beans/PropertyEditor)
$(call RunOthervmBatch)
# Stable othervm testruns (minus items from PROBLEM_LIST)
# Using samevm has serious problems with these tests
JDK_ALL_TARGETS += jdk_beans3
-jdk_beans3: java/beans/XMLEncoder
+jdk_beans3: $(call TestDirs, java/beans/XMLEncoder)
$(call RunOthervmBatch)
# All beans tests
@@ -449,24 +451,24 @@
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_io
-jdk_io: java/io
+jdk_io: $(call TestDirs, java/io)
$(call RunSamevmBatch)
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_lang
-jdk_lang: java/lang
+jdk_lang: $(call TestDirs, java/lang)
$(call RunSamevmBatch)
# Stable othervm testruns (minus items from PROBLEM_LIST)
# Using samevm has serious problems with these tests
JDK_ALL_TARGETS += jdk_management1
-jdk_management1: javax/management
+jdk_management1: $(call TestDirs, javax/management)
$(call RunOthervmBatch)
# Stable othervm testruns (minus items from PROBLEM_LIST)
# Using samevm has serious problems with these tests
JDK_ALL_TARGETS += jdk_management2
-jdk_management2: com/sun/jmx com/sun/management sun/management
+jdk_management2: $(call TestDirs, com/sun/jmx com/sun/management sun/management)
$(call RunOthervmBatch)
# All management tests
@@ -475,36 +477,37 @@
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_math
-jdk_math: java/math
+jdk_math: $(call TestDirs, java/math)
$(call RunSamevmBatch)
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_misc
-jdk_misc: demo javax/imageio javax/naming javax/print javax/script \
+jdk_misc: $(call TestDirs, \
+ demo javax/imageio javax/naming javax/print javax/script \
javax/smartcardio javax/sound com/sun/java com/sun/jndi \
- com/sun/org sun/misc sun/pisces
+ com/sun/org com/sun/xml sun/misc sun/pisces)
$(call RunSamevmBatch)
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_net
-jdk_net: com/sun/net java/net sun/net
+jdk_net: $(call TestDirs, com/sun/net java/net sun/net)
$(call RunSamevmBatch)
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_nio1
-jdk_nio1: java/nio/file
+jdk_nio1: $(call TestDirs, java/nio/file)
$(call RunSamevmBatch)
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_nio2
-jdk_nio2: java/nio/Buffer java/nio/ByteOrder \
- java/nio/channels java/nio/BufferPoolMXBean java/nio/MappedByteBuffer
+jdk_nio2: $(call TestDirs, java/nio/Buffer java/nio/ByteOrder \
+ java/nio/channels java/nio/BufferPoolMXBean java/nio/MappedByteBuffer)
$(call SharedLibraryPermissions,java/nio/channels)
$(call RunSamevmBatch)
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_nio3
-jdk_nio3: com/sun/nio sun/nio
+jdk_nio3: $(call TestDirs, com/sun/nio sun/nio)
$(call RunSamevmBatch)
# All nio tests
@@ -514,24 +517,25 @@
# Stable othervm testruns (minus items from PROBLEM_LIST)
# Using samevm has serious problems with these tests
JDK_ALL_TARGETS += jdk_rmi
-jdk_rmi: java/rmi javax/rmi sun/rmi
+jdk_rmi: $(call TestDirs, java/rmi javax/rmi sun/rmi)
$(call RunOthervmBatch)
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_security1
-jdk_security1: java/security
+jdk_security1: $(call TestDirs, java/security)
$(call RunSamevmBatch)
# Stable othervm testruns (minus items from PROBLEM_LIST)
# Using samevm has serious problems with these tests
JDK_ALL_TARGETS += jdk_security2
-jdk_security2: javax/crypto com/sun/crypto
+jdk_security2: $(call TestDirs, javax/crypto com/sun/crypto)
$(call RunOthervmBatch)
# Stable othervm testruns (minus items from PROBLEM_LIST)
# Using samevm has serious problems with these tests
JDK_ALL_TARGETS += jdk_security3
-jdk_security3: com/sun/security lib/security javax/security sun/security
+jdk_security3: $(call TestDirs, com/sun/security lib/security \
+ javax/security sun/security)
$(call SharedLibraryPermissions,sun/security)
$(call RunOthervmBatch)
@@ -542,23 +546,25 @@
# Stable othervm testruns (minus items from PROBLEM_LIST)
# Using samevm has problems, and doesn't help performance as much as others.
JDK_ALL_TARGETS += jdk_swing
-jdk_swing: javax/swing sun/java2d
+jdk_swing: $(call TestDirs, javax/swing sun/java2d)
$(call RunOthervmBatch)
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_text
-jdk_text: java/text sun/text
+jdk_text: $(call TestDirs, java/text sun/text)
$(call RunSamevmBatch)
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_tools1
-jdk_tools1: com/sun/jdi
+jdk_tools1: $(call TestDirs, com/sun/jdi)
$(call RunSamevmBatch)
# Stable othervm testruns (minus items from PROBLEM_LIST)
# Using samevm has serious problems with these tests
JDK_ALL_TARGETS += jdk_tools2
-jdk_tools2: com/sun/tools sun/jvmstat sun/tools tools vm com/sun/servicetag com/sun/tracing
+jdk_tools2: $(call TestDirs, \
+ com/sun/tools sun/jvmstat sun/tools tools vm \
+ com/sun/servicetag com/sun/tracing)
$(call SharedLibraryPermissions,tools/launcher)
$(call RunSamevmBatch)
@@ -568,7 +574,7 @@
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_util
-jdk_util: java/util sun/util
+jdk_util: $(call TestDirs, java/util sun/util)
$(call RunSamevmBatch)
# ------------------------------------------------------------------
--- a/jdk/test/java/net/URI/Test.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/test/java/net/URI/Test.java Mon Mar 21 16:57:18 2011 -0700
@@ -23,7 +23,7 @@
/* @test
* @summary Unit test for java.net.URI
- * @bug 4464135 4505046 4503239 4438319 4991359 4866303
+ * @bug 4464135 4505046 4503239 4438319 4991359 4866303 7023363
* @author Mark Reinhold
*/
@@ -1050,6 +1050,13 @@
test("http://1.2.3.4.5").psa().x().z();
test("http://[1.2.3.4:5]").x().z();
test("http://1:2:3:4:5:6:7:8").psa().x().z();
+ test("http://[1.2.3.4]/").x().z();
+ test("http://[1.2.3.4/").x().z();
+ test("http://[foo]/").x().z();
+ test("http://[foo/").x().z();
+ test("s", "[foo]", "/", null, null).x().z();
+ test("s", "[foo", "/", null, null).x().z();
+ test("s", "[::foo", "/", null, null).x().z();
// Test hostnames that might initially look like IPv4 addresses
--- a/jdk/test/java/net/URLConnection/GetXmlContentType.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/test/java/net/URLConnection/GetXmlContentType.java Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -23,8 +23,8 @@
/*
* @test
- * @bug 4160195
- * @summary Check for correct detection of XML content type
+ * @bug 4160195 7026346
+ * @summary Check for correct detection of XML content type, including BOM streams
*/
import java.io.*;
@@ -34,6 +34,8 @@
public class GetXmlContentType {
static final String XML_MIME_TYPE = "application/xml";
+ static final String XML_HEADER = "<?xml";
+ static int passed, failed;
// guess type from content and filename
static final String goodFiles [] = {
@@ -50,52 +52,91 @@
};
public static void main(String[] args) throws Exception {
- boolean sawError = false;
+ contentTypeFromFile();
+ contentTypeFromBOMStream();
- //
+ if (failed > 0)
+ throw new RuntimeException (
+ "Test failed; passed = " + passed + ", failed = " + failed);
+ }
+
+ static void contentTypeFromFile() throws Exception {
// POSITIVE tests: good data --> good result
- //
- for (int i = 0; i < goodFiles.length; i++) {
- String result = getUrlContentType (goodFiles [i]);
+
+ for (String goodFile : goodFiles) {
+ String result = getUrlContentType(goodFile);
- if (!XML_MIME_TYPE.equals (result)) {
- System.out.println ("Wrong MIME type: "
- + goodFiles [i]
- + " --> " + result
- );
- sawError = true;
+ if (!XML_MIME_TYPE.equals(result)) {
+ System.out.println("Wrong MIME type: " + goodFile + " --> " + result);
+ failed++;
+ } else {
+ passed++;
}
}
- //
// NEGATIVE tests: bad data --> correct diagnostic
- //
- for (int i = 0; i < badFiles.length; i++) {
- String result = getUrlContentType (badFiles [i]);
+ for (String badFile : badFiles) {
+ String result = getUrlContentType(badFile);
+
+ if (XML_MIME_TYPE.equals(result)) {
+ System.out.println("Wrong MIME type: " + badFile + " --> " + result);
+ failed++;
+ } else {
+ passed++;
+ }
+ }
+ }
+
+ static String getUrlContentType(String name) throws IOException {
+ File file = new File(System.getProperty("test.src", "."), "xml");
+ URL u = new URL("file:"
+ + file.getCanonicalPath()
+ + file.separator
+ + name);
+ URLConnection conn = u.openConnection();
+
+ return conn.getContentType();
+ }
- if (XML_MIME_TYPE.equals (result)) {
- System.out.println ("Wrong MIME type: "
- + badFiles [i]
- + " --> " + result
- );
- sawError = true;
- }
+ static void contentTypeFromBOMStream() throws Exception {
+ final String[] encodings = new String[]
+ {"UTF-8", "UTF-16BE", "UTF-16LE", "UTF-32BE", "UTF-32LE"};
+ for (String encoding : encodings) {
+ try (InputStream is = new ByteArrayInputStream(toBOMBytes(encoding))) {
+ String mime = URLConnection.guessContentTypeFromStream(is);
+ if ( !XML_MIME_TYPE.equals(mime) ) {
+ System.out.println("Wrong MIME type: " + encoding + " --> " + mime);
+ failed++;
+ } else {
+ passed++;
+ }
+ }
+ }
+ }
+
+ static byte[] toBOMBytes(String encoding) throws Exception {
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+
+ switch (encoding) {
+ case "UTF-8" :
+ bos.write(new byte[] { (byte) 0xEF, (byte) 0xBB, (byte) 0xBF });
+ break;
+ case "UTF-16BE" :
+ bos.write(new byte[] { (byte) 0xFE, (byte) 0xFF });
+ break;
+ case "UTF-16LE" :
+ bos.write(new byte[] { (byte) 0xFF, (byte) 0xFE });
+ break;
+ case "UTF-32BE" :
+ bos.write(new byte[] { (byte) 0x00, (byte) 0x00,
+ (byte) 0xFE, (byte) 0xFF });
+ break;
+ case "UTF-32LE" :
+ bos.write(new byte[] { (byte) 0xFF, (byte) 0xFE,
+ (byte) 0x00, (byte) 0x00 });
}
- if (sawError)
- throw new Exception (
- "GetXmlContentType Test failed; see diagnostics.");
+ bos.write(XML_HEADER.getBytes(encoding));
+ return bos.toByteArray();
}
-
- static String getUrlContentType (String name) throws IOException {
- File file = new File(System.getProperty("test.src", "."), "xml");
- URL u = new URL ("file:"
- + file.getCanonicalPath()
- + file.separator
- + name);
- URLConnection conn = u.openConnection ();
-
- return conn.getContentType ();
- }
-
}
--- a/jdk/test/java/nio/channels/DatagramChannel/MulticastSendReceiveTests.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/test/java/nio/channels/DatagramChannel/MulticastSendReceiveTests.java Mon Mar 21 16:57:18 2011 -0700
@@ -22,7 +22,7 @@
*/
/* @test
- * @bug 4527345
+ * @bug 4527345 7026376
* @summary Unit test for DatagramChannel's multicast support
* @build MulticastSendReceiveTests NetworkConfiguration
* @run main MulticastSendReceiveTests
@@ -31,12 +31,19 @@
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.net.*;
+import static java.net.StandardProtocolFamily.*;
import java.util.*;
import java.io.IOException;
public class MulticastSendReceiveTests {
- static Random rand = new Random();
+ static final Random rand = new Random();
+
+ static final ProtocolFamily UNSPEC = new ProtocolFamily() {
+ public String name() {
+ return "UNSPEC";
+ }
+ };
/**
* Send datagram from given local address to given multicast
@@ -130,75 +137,84 @@
/**
* Exercise multicast send/receive on given group/interface
*/
- static void test(NetworkInterface nif, InetAddress group, InetAddress source)
+ static void test(ProtocolFamily family,
+ NetworkInterface nif,
+ InetAddress group,
+ InetAddress source)
throws IOException
{
- ProtocolFamily family = (group instanceof Inet6Address) ?
- StandardProtocolFamily.INET6 : StandardProtocolFamily.INET;
- System.out.format("create channel to %s socket\n", family.name());
- DatagramChannel dc = DatagramChannel.open(family)
- .setOption(StandardSocketOption.SO_REUSEADDR, true)
- .bind(new InetSocketAddress(0));
-
- // join group
- System.out.format("join %s @ %s\n", group.getHostAddress(),
- nif.getName());
- MembershipKey key = dc.join(group, nif);
+ System.out.format("\nTest DatagramChannel to %s socket\n", family.name());
+ try (DatagramChannel dc = (family == UNSPEC) ?
+ DatagramChannel.open() : DatagramChannel.open(family)) {
+ dc.setOption(StandardSocketOption.SO_REUSEADDR, true)
+ .bind(new InetSocketAddress(0));
- // send message to group
- int port = ((InetSocketAddress)dc.getLocalAddress()).getPort();
- int id = sendDatagram(source, nif, group, port);
-
- // receive message and check id matches
- receiveDatagram(dc, source, id);
+ // join group
+ System.out.format("join %s @ %s\n", group.getHostAddress(),
+ nif.getName());
+ MembershipKey key;
+ try {
+ key = dc.join(group, nif);
+ } catch (IllegalArgumentException iae) {
+ if (family == UNSPEC) {
+ System.out.println("Not supported");
+ return;
+ }
+ throw iae;
+ }
- // exclude-mode filtering
-
- try {
- System.out.format("block %s\n", source.getHostAddress());
+ // send message to group
+ int port = ((InetSocketAddress)dc.getLocalAddress()).getPort();
+ int id = sendDatagram(source, nif, group, port);
- // may throw UOE
- key.block(source);
- id = sendDatagram(source, nif, group, port);
- receiveDatagram(dc, null, id);
+ // receive message and check id matches
+ receiveDatagram(dc, source, id);
+
+ // exclude-mode filtering
+
+ try {
+ System.out.format("block %s\n", source.getHostAddress());
- // unblock source, send message, message should be received
- System.out.format("unblock %s\n", source.getHostAddress());
- key.unblock(source);
- id = sendDatagram(source, nif, group, port);
- receiveDatagram(dc, source, id);
- } catch (UnsupportedOperationException x) {
- System.out.println("Exclude-mode filtering not supported!");
- }
+ // may throw UOE
+ key.block(source);
+ id = sendDatagram(source, nif, group, port);
+ receiveDatagram(dc, null, id);
- key.drop();
+ // unblock source, send message, message should be received
+ System.out.format("unblock %s\n", source.getHostAddress());
+ key.unblock(source);
+ id = sendDatagram(source, nif, group, port);
+ receiveDatagram(dc, source, id);
+ } catch (UnsupportedOperationException x) {
+ System.out.println("Exclude-mode filtering not supported!");
+ }
- // include-mode filtering
+ key.drop();
+
+ // include-mode filtering
- InetAddress bogus = (group instanceof Inet6Address) ?
- InetAddress.getByName("fe80::1234") :
- InetAddress.getByName("1.2.3.4");
- System.out.format("join %s @ %s only-source %s\n", group.getHostAddress(),
- nif.getName(), bogus.getHostAddress());
- try {
- // may throw UOE
- key = dc.join(group, nif, bogus);
-
- id = sendDatagram(source, nif, group, port);
- receiveDatagram(dc, null, id);
+ InetAddress bogus = (group instanceof Inet6Address) ?
+ InetAddress.getByName("fe80::1234") :
+ InetAddress.getByName("1.2.3.4");
+ System.out.format("join %s @ %s only-source %s\n", group.getHostAddress(),
+ nif.getName(), bogus.getHostAddress());
+ try {
+ // may throw UOE
+ key = dc.join(group, nif, bogus);
- System.out.format("join %s @ %s only-source %s\n", group.getHostAddress(),
- nif.getName(), source.getHostAddress());
- key = dc.join(group, nif, source);
+ id = sendDatagram(source, nif, group, port);
+ receiveDatagram(dc, null, id);
+
+ System.out.format("join %s @ %s only-source %s\n", group.getHostAddress(),
+ nif.getName(), source.getHostAddress());
+ key = dc.join(group, nif, source);
- id = sendDatagram(source, nif, group, port);
- receiveDatagram(dc, source, id);
- } catch (UnsupportedOperationException x) {
- System.out.println("Include-mode filtering not supported!");
+ id = sendDatagram(source, nif, group, port);
+ receiveDatagram(dc, source, id);
+ } catch (UnsupportedOperationException x) {
+ System.out.println("Include-mode filtering not supported!");
+ }
}
-
- // done
- dc.close();
}
public static void main(String[] args) throws IOException {
@@ -210,12 +226,14 @@
for (NetworkInterface nif: config.ip4Interfaces()) {
InetAddress source = config.ip4Addresses(nif).iterator().next();
- test(nif, ip4Group, source);
+ test(INET, nif, ip4Group, source);
+ test(UNSPEC, nif, ip4Group, source);
}
for (NetworkInterface nif: config.ip6Interfaces()) {
InetAddress source = config.ip6Addresses(nif).iterator().next();
- test(nif, ip6Group, source);
+ test(INET6, nif, ip6Group, source);
+ test(UNSPEC, nif, ip6Group, source);
}
}
}
--- a/jdk/test/java/nio/file/Files/FileAttributes.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/test/java/nio/file/Files/FileAttributes.java Mon Mar 21 16:57:18 2011 -0700
@@ -22,7 +22,7 @@
*/
/* @test
- * @bug 4313887 6838333
+ * @bug 4313887 6838333 7017446
* @summary Unit test for java.nio.file.Files
* @library ..
*/
@@ -94,12 +94,6 @@
assertTrue(map.size() == 2);
checkEqual(attrs.size(), map.get("size"));
checkEqual(attrs.lastModifiedTime(), map.get("lastModifiedTime"));
-
- map = Files.readAttributes(file,
- "basic:lastModifiedTime,lastAccessTime,ShouldNotExist");
- assertTrue(map.size() == 2);
- checkEqual(attrs.lastModifiedTime(), map.get("lastModifiedTime"));
- checkEqual(attrs.lastAccessTime(), map.get("lastAccessTime"));
}
// Exercise getAttribute/setAttribute/readAttributes on posix attributes
@@ -132,7 +126,7 @@
assertTrue(map.size() >= 12);
checkEqual(attrs.permissions(), map.get("permissions")); // check one
- map = Files.readAttributes(file, "posix:size,owner,ShouldNotExist");
+ map = Files.readAttributes(file, "posix:size,owner");
assertTrue(map.size() == 2);
checkEqual(attrs.size(), map.get("size"));
checkEqual(attrs.owner(), map.get("owner"));
@@ -155,7 +149,7 @@
map = Files.readAttributes(file, "unix:*");
assertTrue(map.size() >= 20);
- map = Files.readAttributes(file, "unix:size,uid,gid,ShouldNotExist");
+ map = Files.readAttributes(file, "unix:size,uid,gid");
assertTrue(map.size() == 3);
checkEqual(map.get("size"),
Files.readAttributes(file, BasicFileAttributes.class).size());
@@ -206,14 +200,65 @@
assertTrue(map.size() >= 13);
checkEqual(attrs.isReadOnly(), map.get("readonly")); // check one
- map = Files.readAttributes(file, "dos:size,hidden,ShouldNotExist");
+ map = Files.readAttributes(file, "dos:size,hidden");
assertTrue(map.size() == 2);
checkEqual(attrs.size(), map.get("size"));
checkEqual(attrs.isHidden(), map.get("hidden"));
}
+ static void checkBadSet(Path file, String attribute, Object value)
+ throws IOException
+ {
+ try {
+ Files.setAttribute(file, attribute, 0);
+ throw new RuntimeException("IllegalArgumentException expected");
+ } catch (IllegalArgumentException ignore) { }
+ }
+
+ static void checkBadGet(Path file, String attribute) throws IOException {
+ try {
+ Files.getAttribute(file, attribute);
+ throw new RuntimeException("IllegalArgumentException expected");
+ } catch (IllegalArgumentException ignore) { }
+ }
+
+ static void checkBadRead(Path file, String attribute) throws IOException {
+ try {
+ Files.readAttributes(file, attribute);
+ throw new RuntimeException("IllegalArgumentException expected");
+ } catch (IllegalArgumentException ignore) { }
+ }
+
static void miscTests(Path file) throws IOException {
- // NPE tests
+ // unsupported views
+ try {
+ Files.setAttribute(file, "foo:bar", 0);
+ throw new RuntimeException("UnsupportedOperationException expected");
+ } catch (UnsupportedOperationException ignore) { }
+ try {
+ Files.getAttribute(file, "foo:bar");
+ throw new RuntimeException("UnsupportedOperationException expected");
+ } catch (UnsupportedOperationException ignore) { }
+ try {
+ Files.readAttributes(file, "foo:*");
+ throw new RuntimeException("UnsupportedOperationException expected");
+ } catch (UnsupportedOperationException ignore) { }
+
+ // bad args
+ checkBadSet(file, "", 0);
+ checkBadSet(file, "basic:", 0);
+ checkBadSet(file, "basic:foobar", 0);
+ checkBadGet(file, "");
+ checkBadGet(file, "basic:");
+ checkBadGet(file, "basic:foobar");
+ checkBadGet(file, "basic:size,lastModifiedTime");
+ checkBadGet(file, "basic:*");
+ checkBadRead(file, "");
+ checkBadRead(file, "basic:");
+ checkBadRead(file, "basic:foobar");
+ checkBadRead(file, "basic:size,foobar");
+
+ // nulls
try {
Files.getAttribute(file, null);
throw new RuntimeException("NullPointerException expected");
--- a/jdk/test/java/nio/file/WatchService/Basic.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/test/java/nio/file/WatchService/Basic.java Mon Mar 21 16:57:18 2011 -0700
@@ -22,7 +22,7 @@
*/
/* @test
- * @bug 4313887 6838333
+ * @bug 4313887 6838333 7017446
* @summary Unit test for java.nio.file.WatchService
* @library ..
* @run main/timeout=120 Basic
@@ -44,6 +44,8 @@
static void checkKey(WatchKey key, Path dir) {
if (!key.isValid())
throw new RuntimeException("Key is not valid");
+ if (key.watchable() != dir)
+ throw new RuntimeException("Unexpected watchable");
}
static void takeExpectedKey(WatchService watcher, WatchKey expected) {
--- a/jdk/test/java/nio/file/attribute/UserDefinedFileAttributeView/Basic.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/test/java/nio/file/attribute/UserDefinedFileAttributeView/Basic.java Mon Mar 21 16:57:18 2011 -0700
@@ -141,9 +141,6 @@
map = Files.readAttributes(file, "user:*");
if (!Arrays.equals(valueAsBytes, (byte[])map.get(ATTR_NAME)))
throw new RuntimeException("Unexpected attribute value");
- map = Files.readAttributes(file, "user:DoesNotExist");
- if (!map.isEmpty())
- throw new RuntimeException("Map expected to be empty");
}
static void miscTests(final Path file) throws IOException {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/util/EnumSet/LargeEnumIteratorRemoveResilience.java Mon Mar 21 16:57:18 2011 -0700
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * Portions Copyright (c) 2011 IBM Corporation
+ */
+
+/*
+ * @test
+ * @bug 7014637
+ * @summary EnumSet's iterator.remove() can be resilient to set's modification.
+ * @author Neil Richards <neil.richards@ngmr.net>, <neil_richards@uk.ibm.com>
+ */
+
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.Set;
+
+public class LargeEnumIteratorRemoveResilience {
+ // enum with more than 64 values
+ private static enum LargeEnum {
+ e00, e01, e02, e03, e04, e05, e06, e07,
+ e08, e09, e0A, e0B, e0C, e0D, e0E, e0F,
+ e10, e11, e12, e13, e14, e15, e16, e17,
+ e18, e19, e1A, e1B, e1C, e1D, e1E, e1F,
+ e20, e21, e22, e23, e24, e25, e26, e27,
+ e28, e29, e2A, e2B, e2C, e2D, e2E, e2F,
+ e30, e31, e32, e33, e34, e35, e36, e37,
+ e38, e39, e3A, e3B, e3C, e3D, e3E, e3F,
+ e40, e41, e42, e43, e44, e45, e46, e47,
+ e48, e49, e4A, e4B, e4C, e4D, e4E, e4F,
+ }
+
+ public static void main(final String[] args) throws Exception {
+ final Set<LargeEnum> set = EnumSet.noneOf(LargeEnum.class);
+
+ set.add(LargeEnum.e2D);
+ set.add(LargeEnum.e42);
+
+ final Iterator<LargeEnum> iterator = set.iterator();
+
+ int size = set.size();
+ LargeEnum element = iterator.next();
+
+ iterator.remove();
+ checkSetAfterRemoval(set, size, element);
+
+ size = set.size();
+ element = iterator.next();
+
+ set.remove(element);
+ checkSetAfterRemoval(set, size, element);
+
+ // The Java API declares that the behaviour here - to call
+ // iterator.remove() after the underlying collection has been
+ // modified - is "unspecified".
+ // However, in the case of iterators for EnumSet, it is easy to
+ // implement their remove() operation such that the set is
+ // unmodified if it is called for an element that has already been
+ // removed from the set - this being the naturally "resilient"
+ // behaviour.
+ iterator.remove();
+ checkSetAfterRemoval(set, size, element);
+ }
+
+ private static void checkSetAfterRemoval(final Set<LargeEnum> set,
+ final int origSize, final LargeEnum removedElement)
+ throws Exception {
+ if (set.size() != (origSize - 1)) {
+ throw new Exception("Test FAILED: Unexpected set size after removal; expected '" + (origSize - 1) + "' but found '" + set.size() + "'");
+ }
+ if (set.contains(removedElement)) {
+ throw new Exception("Test FAILED: Element returned from iterator unexpectedly still in set after removal.");
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/util/EnumSet/SmallEnumIteratorRemoveResilience.java Mon Mar 21 16:57:18 2011 -0700
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * Portions Copyright (c) 2011 IBM Corporation
+ */
+
+/*
+ * @test
+ * @bug 7014637
+ * @summary EnumSet's iterator.remove() can be resilient to set's modification.
+ * @author Neil Richards <neil.richards@ngmr.net>, <neil_richards@uk.ibm.com>
+ */
+
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.Set;
+
+public class SmallEnumIteratorRemoveResilience {
+ // enum with less than 64 values
+ private static enum SmallEnum { e0, e1, e2 }
+
+ public static void main(final String[] args) throws Exception {
+ final Set<SmallEnum> set = EnumSet.noneOf(SmallEnum.class);
+
+ set.add(SmallEnum.e0);
+ set.add(SmallEnum.e1);
+
+ final Iterator<SmallEnum> iterator = set.iterator();
+
+ int size = set.size();
+ SmallEnum element = iterator.next();
+
+ iterator.remove();
+ checkSetAfterRemoval(set, size, element);
+
+ size = set.size();
+ element = iterator.next();
+
+ set.remove(element);
+ checkSetAfterRemoval(set, size, element);
+
+ // The Java API declares that the behaviour here - to call
+ // iterator.remove() after the underlying collection has been
+ // modified - is "unspecified".
+ // However, in the case of iterators for EnumSet, it is easy to
+ // implement their remove() operation such that the set is
+ // unmodified if it is called for an element that has already been
+ // removed from the set - this being the naturally "resilient"
+ // behaviour.
+ iterator.remove();
+ checkSetAfterRemoval(set, size, element);
+ }
+
+ private static void checkSetAfterRemoval(final Set<SmallEnum> set,
+ final int origSize, final SmallEnum removedElement)
+ throws Exception {
+ if (set.size() != (origSize - 1)) {
+ throw new Exception("Test FAILED: Unexpected set size after removal; expected '" + (origSize - 1) + "' but found '" + set.size() + "'");
+ }
+ if (set.contains(removedElement)) {
+ throw new Exception("Test FAILED: Element returned from iterator unexpectedly still in set after removal.");
+ }
+ }
+}
--- a/jdk/test/java/util/Locale/LocaleEnhanceTest.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/test/java/util/Locale/LocaleEnhanceTest.java Mon Mar 21 16:57:18 2011 -0700
@@ -43,7 +43,7 @@
/**
* @test
- * @bug 6875847
+ * @bug 6875847 6992272 7002320 7015500 7023613
* @summary test API changes to Locale
*/
public class LocaleEnhanceTest extends LocaleTestFmwk {
@@ -83,7 +83,7 @@
"en-Latn-US-NewYork", "en_US_NewYork_#Latn",
"en-Latn-US", "en_US_#Latn",
"en-Latn-NewYork", "en__NewYork_#Latn", // double underscore
- "en-Latn", "en_#Latn",
+ "en-Latn", "en__#Latn", // double underscore
"en-US-NewYork", "en_US_NewYork",
"en-US", "en_US",
"en-NewYork", "en__NewYork", // double underscore
@@ -1259,6 +1259,22 @@
}
}
+ public void testBug7023613() {
+ String[][] testdata = {
+ {"en-Latn", "en__#Latn"},
+ {"en-u-ca-japanese", "en__#u-ca-japanese"},
+ };
+
+ for (String[] data : testdata) {
+ String in = data[0];
+ String expected = (data.length == 1) ? data[0] : data[1];
+
+ Locale loc = Locale.forLanguageTag(in);
+ String out = loc.toString();
+ assertEquals("Empty country field with non-empty script/extension with input: " + in, expected, out);
+ }
+ }
+
///
/// utility asserts
///
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/util/TreeMap/EmptyMapAndNulls.java Mon Mar 21 16:57:18 2011 -0700
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 5045147
+ * @summary Test handling of null with empty Map
+ * @author Mike Duigou
+ */
+
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+import java.lang.reflect.*;
+
+public class EmptyMapAndNulls {
+
+ @SuppressWarnings("rawtypes")
+ static void realMain(String[] args) throws Throwable {
+ // No comparator
+ Map<String,String> comparable = new TreeMap<>();
+
+ // insert null into empty map (5045147 failure)
+ try {
+ comparable.put(null, "anything");
+ fail("null shouldn't be accepted");
+ } catch (NullPointerException failed) {
+ pass();
+ }
+
+ // insert non-null into empty map
+ try {
+ comparable.put("test", "anything");
+ pass();
+ } catch (NullPointerException failed) {
+ fail();
+ }
+
+ // insert null into non-empty map
+ try {
+ comparable.put(null, "anything");
+ fail("null shouldn't be accepted");
+ } catch (NullPointerException failed) {
+ pass();
+ }
+
+ // Comparator (String.CASE_INSENSITIVE_ORDER). Intentionally a raw type.
+ Map comparator = new TreeMap(String.CASE_INSENSITIVE_ORDER);
+
+ // insert null into empty map (5045147 failure)
+ try {
+ comparator.put(null, "anything");
+ fail("null shouldn't be accepted");
+ } catch (NullPointerException failed) {
+ pass();
+ }
+
+ // insert non-null into empty map
+ try {
+ comparator.put("test", "anything");
+ pass();
+ } catch (NullPointerException failed) {
+ fail();
+ }
+
+ // insert null into non-empty map
+ try {
+ comparator.put(null, "anything");
+ fail("null shouldn't be accepted");
+ } catch (NullPointerException failed) {
+ pass();
+ }
+
+ comparator.clear();
+
+ // insert non-String into empty map (5045147 failure)
+ try {
+ comparator.put(new Object(), "anything");
+ fail("Object shouldn't be accepted");
+ } catch (ClassCastException failed) {
+ pass();
+ }
+
+ }
+
+ //--------------------- Infrastructure ---------------------------
+ static volatile int passed = 0, failed = 0;
+ static void pass() {passed++;}
+ static void fail() {failed++; Thread.dumpStack();}
+ static void fail(String msg) {System.out.println(msg); fail();}
+ static void unexpected(Throwable t) {failed++; t.printStackTrace();}
+ static void check(boolean cond) {if (cond) pass(); else fail();}
+ static void equal(Object x, Object y) {
+ if (x == null ? y == null : x.equals(y)) pass();
+ else fail(x + " not equal to " + y);}
+ public static void main(String[] args) throws Throwable {
+ try {realMain(args);} catch (Throwable t) {unexpected(t);}
+ System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
+ if (failed > 0) throw new AssertionError("Some tests failed");}
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/script/GetInterfaceTest.java Mon Mar 21 16:57:18 2011 -0700
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 6960211
+ * @summary JavaScript engine allows creation of interface although methods not available.
+ */
+
+import javax.script.*;
+
+public class GetInterfaceTest {
+ public static void main(String[] args) throws Exception {
+ ScriptEngineManager manager = new ScriptEngineManager();
+ ScriptEngine engine = manager.getEngineByName("js");
+
+ if (engine == null) {
+ System.out.println("Warning: No engine engine found; test vacuously passes.");
+ return;
+ }
+
+ // don't define any function.
+ engine.eval("");
+
+ Runnable runnable = ((Invocable)engine).getInterface(Runnable.class);
+ if (runnable != null) {
+ throw new RuntimeException("runnable is not null!");
+ }
+
+ // now define "run"
+ engine.eval("function run() { println('this is run function'); }");
+ runnable = ((Invocable)engine).getInterface(Runnable.class);
+ // should not return null now!
+ runnable.run();
+
+ // define only one method of "Foo2"
+ engine.eval("function bar() { println('bar function'); }");
+ Foo2 foo2 = ((Invocable)engine).getInterface(Foo2.class);
+ if (foo2 != null) {
+ throw new RuntimeException("foo2 is not null!");
+ }
+
+ // now define other method of "Foo2"
+ engine.eval("function bar2() { println('bar2 function'); }");
+ foo2 = ((Invocable)engine).getInterface(Foo2.class);
+ foo2.bar();
+ foo2.bar2();
+ }
+
+ interface Foo {
+ public void bar();
+ }
+
+ interface Foo2 extends Foo {
+ public void bar2();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/sun/nio/cs/TestIBM1364.java Mon Mar 21 16:57:18 2011 -0700
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+/* @test
+ @bug 6803681
+ @summary Test IBM1364
+ */
+
+import java.util.Arrays;
+import java.nio.*;
+import java.nio.charset.*;
+
+public class TestIBM1364 {
+ private static String c2bNRStr = "\u00AD\u00B7\u2015\u223C\u2299\uFF5E";
+ private static byte[] c2bNRBytes = new byte[] {
+ (byte)0x0e,
+ (byte)0x41, (byte)0x48,
+ (byte)0x41, (byte)0x43,
+ (byte)0x41, (byte)0x49,
+ (byte)0x42, (byte)0xa1,
+ (byte)0x49, (byte)0x6f,
+ (byte)0x49, (byte)0x54,
+ (byte)0x0f };
+
+ // end at SO
+ private static String mixedStr = "\u008d\u008e\u0020\u3000\u3001\u71ba\u3164\u0088\ue757";
+ private static byte[] mixedBytes = new byte[] {
+ (byte)0x09,
+ (byte)0x0a,
+ (byte)0x40,
+ (byte)0x0e,
+ (byte)0x40, (byte)0x40,
+ (byte)0x41, (byte)0x41,
+ (byte)0x6c, (byte)0x45,
+ (byte)0x84, (byte)0x41,
+ (byte)0x0f,
+ (byte)0x28,
+ (byte)0x0e,
+ (byte)0xdd, (byte)0xfd,
+ (byte)0x0f };
+
+ // end at SI
+ private static String mixedStr2 = "\u008d\u008e\u0020\u3000\u3001\u71ba\u3164\u0088";
+ private static byte[] mixedBytes2 = new byte[] {
+ (byte)0x09,
+ (byte)0x0a,
+ (byte)0x40,
+ (byte)0x0e,
+ (byte)0x40, (byte)0x40,
+ (byte)0x41, (byte)0x41,
+ (byte)0x6c, (byte)0x45,
+ (byte)0x84, (byte)0x41,
+ (byte)0x0f,
+ (byte)0x28 };
+
+ private static byte[][] malformedBytes = {
+ { (byte)0x0e,
+ (byte)0x039, (byte)0x40,
+ (byte)0x0f
+ },
+ { (byte)0x0e,
+ (byte)0x039, (byte)0x42,
+ (byte)0x0f
+ },
+ { (byte)0x0e,
+ (byte)0x040, (byte)0x41,
+ (byte)0x0f
+ },
+ { (byte)0x0e,
+ (byte)0x040, (byte)0xee,
+ (byte)0x0f
+ },
+ { (byte)0x0e,
+ (byte)0x0ef, (byte)0x30,
+ (byte)0x0f
+ },
+ { (byte)0x0e,
+ (byte)0x0ff, (byte)0x41,
+ (byte)0x0f
+ }
+ };
+
+ private static byte[][] unmappedBytes = {
+ { (byte)0x0e,
+ (byte)0x06c, (byte)0x46,
+ (byte)0x0f,
+ },
+ { (byte)0x0e,
+ (byte)0x078, (byte)0x46,
+ (byte)0x0f,
+ },
+ { (byte)0x0e,
+ (byte)0x083, (byte)0xfe,
+ (byte)0x0f,
+ },
+ { (byte)0xfa },
+ { (byte)0xfe },
+ };
+
+ public static void main(String[] args) throws Exception {
+ if (!(Arrays.equals(mixedStr.getBytes("cp1364"), mixedBytes)) ||
+ !mixedStr.equals(new String(mixedBytes, "cp1364")))
+ throw new RuntimeException("cp1364 failed on mixed!");
+
+ if (!(Arrays.equals(mixedStr2.getBytes("cp1364"), mixedBytes2)) ||
+ !mixedStr2.equals(new String(mixedBytes2, "cp1364")))
+ throw new RuntimeException("cp1364 failed on mixed!");
+
+ if (!(Arrays.equals(c2bNRStr.getBytes("cp1364"), c2bNRBytes)) ||
+ c2bNRStr.equals(new String(c2bNRBytes, "cp1364")))
+ throw new RuntimeException("cp1364 failed on c2bNR!");
+
+ ByteBuffer bb = ByteBuffer.allocateDirect(mixedBytes.length);
+ bb.put(mixedBytes).flip();
+ CharBuffer cb = Charset.forName("ibm1364").decode(bb);
+ if (!mixedStr.equals(new String(cb.toString())))
+ throw new RuntimeException("cp1364 failed on direct decod()!");
+
+ bb = ByteBuffer.allocateDirect(mixedBytes2.length);
+ bb.put(mixedBytes2).flip();
+ cb = Charset.forName("ibm1364").decode(bb);
+ if (!mixedStr2.equals(new String(cb.toString())))
+ throw new RuntimeException("cp1364 failed on direct decod()!");
+
+ cb = ByteBuffer.allocateDirect(mixedStr.length() * 2).asCharBuffer();
+ cb.put(mixedStr.toCharArray()).flip();
+ bb = Charset.forName("x-ibm1364").encode(cb);
+ if (!(Arrays.equals(Arrays.copyOf(bb.array(), bb.limit()), mixedBytes)))
+ throw new RuntimeException("cp1364 failed on direct encode()!");
+
+ cb = ByteBuffer.allocateDirect(mixedStr2.length() * 2).asCharBuffer();
+ cb.put(mixedStr2.toCharArray()).flip();
+ bb = Charset.forName("x-ibm1364").encode(cb);
+ if (!(Arrays.equals(Arrays.copyOf(bb.array(), bb.limit()), mixedBytes2)))
+ throw new RuntimeException("cp1364 failed on direct encode()!");
+
+ // malformed
+ cb = CharBuffer.allocate(1024);
+ CharBuffer cbd = ByteBuffer.allocateDirect(1024).asCharBuffer();
+ CharsetDecoder dec = Charset.forName("x-ibm1364").newDecoder();
+ for (byte[] ba:malformedBytes) {
+ cb.clear();
+ dec.reset();
+ if (!dec.reset().decode(ByteBuffer.wrap(ba), cb, true).isMalformed() ||
+ !dec.reset().decode(ByteBuffer.wrap(ba), cbd, true).isMalformed())
+ throw new RuntimeException("cp1364 failed on decode()/malformed!");
+ }
+
+ //unmappable
+ for (byte[] ba:unmappedBytes) {
+ cb.clear();
+ dec.reset();
+ if (!dec.reset().decode(ByteBuffer.wrap(ba), cb, true).isUnmappable() ||
+ !dec.reset().decode(ByteBuffer.wrap(ba), cbd, true).isUnmappable())
+ throw new RuntimeException("cp1364 failed on decode()/unmappable!");
+ }
+
+ //overflow
+ cb.limit(mixedStr.length() - 1);
+ cbd.limit(mixedStr.length() - 1);
+ if (!dec.reset().decode(ByteBuffer.wrap(mixedBytes), cb, true).isOverflow() ||
+ !dec.reset().decode(ByteBuffer.wrap(mixedBytes), cbd, true).isOverflow())
+ throw new RuntimeException("cp1364 failed on decode()/overflow!");
+
+ CharsetEncoder enc = Charset.forName("x-ibm1364").newEncoder();
+ // last "0x0f" is from flush()
+ bb = ByteBuffer.allocate(mixedBytes.length - 2);
+ ByteBuffer bbd = ByteBuffer.allocateDirect(mixedBytes.length - 2);
+ if (!enc.reset()
+ .encode(CharBuffer.wrap(mixedStr.toCharArray()), bb, true)
+ .isOverflow() ||
+ !enc.reset()
+ .encode(CharBuffer.wrap(mixedStr.toCharArray()), bbd, true)
+ .isOverflow())
+ throw new RuntimeException("cp1364 failed on encode()/overflow!");
+
+ // flush() overflow
+ bb = ByteBuffer.allocate(mixedBytes.length - 1);
+ bbd = ByteBuffer.allocateDirect(mixedBytes.length - 1);
+
+ enc.reset().encode(CharBuffer.wrap(mixedStr.toCharArray()), bb, true);
+ enc.reset().encode(CharBuffer.wrap(mixedStr.toCharArray()), bbd, true);
+
+ if (!enc.flush(bb).isOverflow() ||
+ !enc.flush(bbd).isOverflow())
+ throw new RuntimeException("cp1364 failed on encode()/flush()/overflow!");
+ }
+}
--- a/jdk/test/sun/security/mscapi/access.policy Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/test/sun/security/mscapi/access.policy Mon Mar 21 16:57:18 2011 -0700
@@ -3,7 +3,7 @@
permission java.lang.RuntimePermission
"accessClassInPackage.sun.*";
- permission java.lang.RuntimePermission "loadLibrary.sunmscapi";
+ permission java.lang.RuntimePermission "loadLibrary.*";
permission java.util.PropertyPermission "os.arch", "read";
--- a/jdk/test/sun/security/mscapi/noaccess.policy Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/test/sun/security/mscapi/noaccess.policy Mon Mar 21 16:57:18 2011 -0700
@@ -3,7 +3,7 @@
permission java.lang.RuntimePermission
"accessClassInPackage.sun.*";
- permission java.lang.RuntimePermission "loadLibrary.sunmscapi";
+ permission java.lang.RuntimePermission "loadLibrary.*";
permission java.util.PropertyPermission "os.arch", "read";
--- a/jdk/test/sun/security/ssl/javax/net/ssl/GetInstance.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/test/sun/security/ssl/javax/net/ssl/GetInstance.java Mon Mar 21 16:57:18 2011 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -23,8 +23,9 @@
/*
* @test
- * @bug 4898428
+ * @bug 4898428 7022855
* @summary verify getInstance() works using Provider.getService()
+ * Export "PKIX" as the standard algorithm name of KeyManagerFactory
* @author Andreas Sterbenz
*/
@@ -61,6 +62,20 @@
kmf = KeyManagerFactory.getInstance("SunX509", p);
same(p, kmf.getProvider());
+ kmf = KeyManagerFactory.getInstance("NewSunX509");
+ same(p, kmf.getProvider());
+ kmf = KeyManagerFactory.getInstance("NewSunX509", "SunJSSE");
+ same(p, kmf.getProvider());
+ kmf = KeyManagerFactory.getInstance("NewSunX509", p);
+ same(p, kmf.getProvider());
+
+ kmf = KeyManagerFactory.getInstance("PKIX");
+ same(p, kmf.getProvider());
+ kmf = KeyManagerFactory.getInstance("PKIX", "SunJSSE");
+ same(p, kmf.getProvider());
+ kmf = KeyManagerFactory.getInstance("PKIX", p);
+ same(p, kmf.getProvider());
+
TrustManagerFactory tmf;
tmf = TrustManagerFactory.getInstance("SunX509");
same(p, tmf.getProvider());
@@ -69,6 +84,34 @@
tmf = TrustManagerFactory.getInstance("SunX509", p);
same(p, tmf.getProvider());
+ tmf = TrustManagerFactory.getInstance("PKIX");
+ same(p, tmf.getProvider());
+ tmf = TrustManagerFactory.getInstance("PKIX", "SunJSSE");
+ same(p, tmf.getProvider());
+ tmf = TrustManagerFactory.getInstance("PKIX", p);
+ same(p, tmf.getProvider());
+
+ tmf = TrustManagerFactory.getInstance("SunPKIX");
+ same(p, tmf.getProvider());
+ tmf = TrustManagerFactory.getInstance("SunPKIX", "SunJSSE");
+ same(p, tmf.getProvider());
+ tmf = TrustManagerFactory.getInstance("SunPKIX", p);
+ same(p, tmf.getProvider());
+
+ tmf = TrustManagerFactory.getInstance("X509");
+ same(p, tmf.getProvider());
+ tmf = TrustManagerFactory.getInstance("X509", "SunJSSE");
+ same(p, tmf.getProvider());
+ tmf = TrustManagerFactory.getInstance("X509", p);
+ same(p, tmf.getProvider());
+
+ tmf = TrustManagerFactory.getInstance("X.509");
+ same(p, tmf.getProvider());
+ tmf = TrustManagerFactory.getInstance("X.509", "SunJSSE");
+ same(p, tmf.getProvider());
+ tmf = TrustManagerFactory.getInstance("X.509", p);
+ same(p, tmf.getProvider());
+
testComSun();
long stop = System.currentTimeMillis();
--- a/jdk/test/tools/launcher/MiscTests.java Mon Mar 21 16:55:14 2011 -0700
+++ b/jdk/test/tools/launcher/MiscTests.java Mon Mar 21 16:57:18 2011 -0700
@@ -23,8 +23,8 @@
/*
* @test
- * @bug 6856415 6981001
- * @summary Miscellaneous tests, Exceptions, EnsureJRE etc.
+ * @bug 6856415
+ * @summary Miscellaneous tests, Exceptions
* @compile -XDignore.symbol.file MiscTests.java TestHelper.java
* @run main MiscTests
*/
@@ -32,9 +32,6 @@
import java.io.File;
import java.io.FileNotFoundException;
-import java.util.HashMap;
-import java.util.Map;
-
public class MiscTests {
@@ -67,22 +64,9 @@
System.out.println(tr.status);
}
}
- // 6981001 : Check EnsureJreInstallation is ok, note we cannot
- // thoroughly test this function, we simply do our best.
- static void test6981001() {
- if (TestHelper.is64Bit || !TestHelper.isWindows) {
- return;
- }
- Map<String, String> env = new HashMap<String, String>();
- env.put("_JAVA_LAUNCHER_DEBUG", "true");
- TestHelper.TestResult tr = TestHelper.doExec(env, TestHelper.javaCmd);
- if (!tr.contains(TestHelper.JAVAHOME + "\\lib\\bundles")) {
- System.out.println(tr.status);
- }
- }
+
public static void main(String... args) {
test6856415();
- test6981001();
if (TestHelper.testExitValue != 0) {
throw new Error(TestHelper.testExitValue + " tests failed");
}