haxe_3.2.1+dfsg.orig/.travis.yml 0000664 0001750 0001750 00000004666 12607337712 016451 0 ustar andy andy 0000000 0000000 language: cpp
os:
- linux
- osx
env:
global:
# make variables
- OCAMLC=ocamlc.opt
- OCAMLOPT=ocamlopt.opt
- ADD_REVISION=1
# SAUCE_USERNAME
- secure: SjyKefmjUEXi0IKHGGpcbLAajU0mLHONg8aA8LoY7Q9nAkSN6Aql+fzS38Boq7w1jWn+2FOpr+4jy0l6wVd/bftsF+huFfYpFJmdh8BlKmE0K71zZAral0H1c7YxkuQpPiJCIFGXqtkvev7SWTy0z31u7kuuQeEyW27boXe5cDA=
# SAUCE_ACCESS_KEY
- secure: sUvWUjCyPuWht4seNa4f2VG9DkvXkhZyLZfjJO9TUAHB2JndS16E2j/qrvKEjycyH6w8tU/B9vnjDRvvGrYXxEXcBEwsJVfkorFnRl9uwGCGIYrzjMhssEl3fMYZK7P304f+gAp5ULrDBX2gIaKeSa8lUNRtz2PsZOieE4kMdhk=
matrix:
- TEST=third-party
- TEST=macro
- TEST=neko
- TEST=js
- TEST=php
- TEST=cpp
- TEST=flash9
- TEST=as3
- TEST=java
- TEST=cs
- TEST=python
matrix:
# fast_finish: true #https://github.com/travis-ci/travis-ci/issues/1696
before_script:
- if [ "${TRAVIS_OS_NAME}" = "linux" ]; then
mysql -u root -e "CREATE DATABASE haxe_test;";
fi
install:
# For our forks that do not have mult-os enabled...
- if [ -z "${TRAVIS_OS_NAME}" ]; then
export TRAVIS_OS_NAME=linux;
fi
# Install haxe and neko dependencies
- if [ "${TRAVIS_OS_NAME}" = "linux" ]; then
travis_retry sudo apt-get update -qq;
travis_retry sudo apt-get install ocaml-native-compilers zlib1g-dev libgc-dev -qq;
fi
- if [ "${TRAVIS_OS_NAME}" = "osx" ]; then
travis_retry brew update;
travis_retry brew install caskroom/cask/brew-cask;
travis_retry brew install ocaml camlp4;
fi
# Install neko
- if [ "${TRAVIS_OS_NAME}" = "linux" ]; then
travis_retry git clone https://github.com/HaxeFoundation/neko.git ~/neko;
cd ~/neko && make os=${TRAVIS_OS_NAME} -s && sudo make install -s;
cd $TRAVIS_BUILD_DIR;
fi
- if [ "${TRAVIS_OS_NAME}" = "osx" ]; then
travis_retry brew install neko --HEAD;
fi
script:
- make -s
- make tools -s
- sudo make install -s
- cd tests/
- mkdir ~/haxelib && haxelib setup ~/haxelib
- haxe -version
- haxe RunCi.hxml
- neko RunCi.n
branches:
except:
# A hack to prevent building for tags, assuming they all start with a number.
# https://github.com/travis-ci/travis-ci/issues/1532
- /^[0-9]/
notifications:
webhooks:
urls:
- https://webhooks.gitter.im/e/95a5fa471c27beee8e7c
on_success: change # options: [always|never|change] default: always
on_failure: always # options: [always|never|change] default: always
on_start: false # default: false
haxe_3.2.1+dfsg.orig/CONTRIBUTING.md 0000664 0001750 0001750 00000002702 12607337712 016556 0 ustar andy andy 0000000 0000000 Things to check before/while filing an issue:
- Check if you actually suspect that there's an issue in the Haxe code. If you find yourself writing "How do I..." you may want to consider a different communication channel. Refer to http://haxe.org/community/community-support.html for more information.
- Reduce your code to a minimal example (see http://sscce.org/). In particular avoid library dependencies: If you cannot reproduce your issue without using a specific library, it might not be a Haxe issue to begin with.
- Check if your problems are already resolved in the Haxe development version (for builds see http://builds.haxe.org/).
- Most targets produce readable code. If you suspect the generated code to be wrong, try checking the output. Note that you can add `-D dump=pretty` to your compilation parameters and find the code which is passed to the generators in a `dump` sub directory.
Other remarks:
- Sometimes people try to be particularly helpful by not only including broken parts in their code, but also "similar" code which is working. More often than not this is more distracting than helpful. If you want to highlight something like this, consider adding the working code commented out.
- We do not require a classic "What do you see/what do you expect?" form, but in some cases it is hard to figure out where you think the actual problem is otherwise.
- We're keeping this page quite short so there's a higher chance that people actually read it.
haxe_3.2.1+dfsg.orig/Makefile 0000664 0001750 0001750 00000022540 12607337712 015767 0 ustar andy andy 0000000 0000000 # Haxe compiler Makefile
#
# - use 'make' to build all
# - use 'make haxe' to build only the compiler (not the libraries)
# - if you want to build quickly, install 'ocamlopt.opt' and change OCAMLOPT=ocamlopt.opt
#
# Windows users :
# - use 'make -f Makefile.win' to build for Windows
# - use 'make MSVC=1 -f Makefile.win' to build for Windows with OCaml/MSVC
#
.SUFFIXES : .ml .mli .cmo .cmi .cmx .mll .mly
INSTALL_DIR=/usr
INSTALL_BIN_DIR=$(INSTALL_DIR)/bin
INSTALL_LIB_DIR=$(INSTALL_DIR)/lib/haxe
OUTPUT=haxe
EXTENSION=
OCAMLOPT?=ocamlopt
OCAMLC?=ocamlc
LFLAGS=
CFLAGS= -g -I libs/extlib -I libs/extc -I libs/neko -I libs/javalib -I libs/ziplib -I libs/swflib -I libs/xml-light -I libs/ttflib -I libs/ilib -I libs/objsize
LIBS=unix str libs/extlib/extLib libs/xml-light/xml-light libs/swflib/swflib \
libs/extc/extc libs/neko/neko libs/javalib/java libs/ziplib/zip \
libs/ttflib/ttf libs/ilib/il libs/objsize/objsize
NATIVE_LIBS=-cclib libs/extc/extc_stubs.o -cclib libs/extc/process_stubs.o -cclib -lz -cclib libs/objsize/c_objsize.o
ifeq ($(BYTECODE),1)
TARGET_FLAG = bytecode
COMPILER = $(OCAMLC)
LIB_EXT = cma
MODULE_EXT = cmo
NATIVE_LIB_FLAG = -custom
else
TARGET_FLAG = native
COMPILER = $(OCAMLOPT)
LIB_EXT = cmxa
MODULE_EXT = cmx
endif
CC_CMD = $(COMPILER) $(CFLAGS) -c $<
CC_PARSER_CMD = $(COMPILER) -pp camlp4o $(CFLAGS) -c parser.ml
RELDIR=../../..
MODULES=ast type lexer common genxml parser typecore optimizer typeload \
codegen gencommon genas3 gencpp genjs genneko genphp \
genswf9 genswf genjava gencs genpy interp dce analyzer filters typer matcher version main
ADD_REVISION?=0
BRANCH=$(shell echo $$APPVEYOR_REPO_NAME | grep -q /haxe && echo $$APPVEYOR_REPO_BRANCH || echo $$TRAVIS_REPO_SLUG | grep -q /haxe && echo $$TRAVIS_BRANCH || git rev-parse --abbrev-ref HEAD)
COMMIT_SHA=$(shell git rev-parse --short HEAD)
COMMIT_DATE=$(shell git show -s --format=%ci HEAD | grep -oh ....-..-..)
PACKAGE_FILE_NAME=haxe_$(COMMIT_DATE)_$(BRANCH)_$(COMMIT_SHA)
# using $(CURDIR) on Windows will not work since it might be a Cygwin path
ifdef SYSTEMROOT
EXTENSION=.exe
else
export HAXE_STD_PATH=$(CURDIR)/std
endif
all: libs haxe
libs:
make -C libs/extlib OCAMLOPT=$(OCAMLOPT) OCAMLC=$(OCAMLC) $(TARGET_FLAG)
make -C libs/extc OCAMLOPT=$(OCAMLOPT) OCAMLC=$(OCAMLC) $(TARGET_FLAG)
make -C libs/neko OCAMLOPT=$(OCAMLOPT) OCAMLC=$(OCAMLC) $(TARGET_FLAG)
make -C libs/javalib OCAMLOPT=$(OCAMLOPT) OCAMLC=$(OCAMLC) $(TARGET_FLAG)
make -C libs/ilib OCAMLOPT=$(OCAMLOPT) OCAMLC=$(OCAMLC) $(TARGET_FLAG)
make -C libs/ziplib OCAMLOPT=$(OCAMLOPT) OCAMLC=$(OCAMLC) $(TARGET_FLAG)
make -C libs/swflib OCAMLOPT=$(OCAMLOPT) OCAMLC=$(OCAMLC) $(TARGET_FLAG)
make -C libs/xml-light OCAMLOPT=$(OCAMLOPT) OCAMLC=$(OCAMLC) $(TARGET_FLAG)
make -C libs/ttflib OCAMLOPT=$(OCAMLOPT) OCAMLC=$(OCAMLC) $(TARGET_FLAG)
make -C libs/objsize OCAMLOPT=$(OCAMLOPT) OCAMLC=$(OCAMLC) $(TARGET_FLAG)
haxe: $(MODULES:=.$(MODULE_EXT))
$(COMPILER) -o $(OUTPUT) $(NATIVE_LIBS) $(NATIVE_LIB_FLAG) $(LFLAGS) $(LIBS:=.$(LIB_EXT)) $(MODULES:=.$(MODULE_EXT))
haxelib:
(cd $(CURDIR)/extra/haxelib_src && $(CURDIR)/$(OUTPUT) haxelib.hxml && nekotools boot bin/haxelib.n)
cp extra/haxelib_src/bin/haxelib$(EXTENSION) haxelib$(EXTENSION)
tools: haxelib
install:
-rm -f $(INSTALL_LIB_DIR)
-mkdir -p $(INSTALL_LIB_DIR)
rm -rf $(INSTALL_LIB_DIR)/std
cp -rf std $(INSTALL_LIB_DIR)/std
cp -rf extra $(INSTALL_LIB_DIR)
-mkdir -p $(INSTALL_LIB_DIR)/lib
rm -f $(INSTALL_BIN_DIR)/haxe
cp haxe $(INSTALL_LIB_DIR)
ln -s $(INSTALL_LIB_DIR)/haxe $(INSTALL_BIN_DIR)/haxe
chmod -R a+rx $(INSTALL_LIB_DIR)
chmod 777 $(INSTALL_LIB_DIR)/lib
# cp extra/haxelib_src/haxelib_script.sh $(INSTALL_DIR)/bin/haxelib
echo "#!/bin/sh" > $(INSTALL_BIN_DIR)/haxelib
echo "exec haxe -cp $(INSTALL_LIB_DIR)/extra/haxelib_src/src --run tools.haxelib.Main \"\$$@\"" >> $(INSTALL_BIN_DIR)/haxelib
chmod a+rx $(INSTALL_BIN_DIR)/haxe $(INSTALL_BIN_DIR)/haxelib
# will install native version of the tools instead of script ones
install_tools: tools
cp haxelib ${INSTALL_BIN_DIR}/haxelib
chmod a+rx $(INSTALL_BIN_DIR)/haxelib
uninstall:
rm -rf $(INSTALL_BIN_DIR)/haxe $(INSTALL_BIN_DIR)/haxelib $(INSTALL_LIB_DIR)
# Modules
analyzer.$(MODULE_EXT): ast.$(MODULE_EXT) type.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT)
codegen.$(MODULE_EXT): optimizer.$(MODULE_EXT) typeload.$(MODULE_EXT) typecore.$(MODULE_EXT) type.$(MODULE_EXT) genxml.$(MODULE_EXT) common.$(MODULE_EXT) ast.$(MODULE_EXT)
common.$(MODULE_EXT): type.$(MODULE_EXT) ast.$(MODULE_EXT) libs/ilib/il.$(LIB_EXT)
dce.$(MODULE_EXT): ast.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) type.$(MODULE_EXT)
filters.$(MODULE_EXT): ast.$(MODULE_EXT) analyzer.$(MODULE_EXT) common.$(MODULE_EXT) type.$(MODULE_EXT) dce.$(MODULE_EXT) codegen.$(MODULE_EXT) typecore.$(MODULE_EXT)
genas3.$(MODULE_EXT): type.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) ast.$(MODULE_EXT)
gencommon.$(MODULE_EXT): type.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) ast.$(MODULE_EXT) libs/ilib/il.$(LIB_EXT)
gencpp.$(MODULE_EXT): type.$(MODULE_EXT) lexer.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) ast.$(MODULE_EXT) gencommon.$(MODULE_EXT)
gencs.$(MODULE_EXT): type.$(MODULE_EXT) lexer.$(MODULE_EXT) gencommon.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) ast.$(MODULE_EXT) libs/ilib/il.$(LIB_EXT)
genjava.$(MODULE_EXT): type.$(MODULE_EXT) gencommon.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) ast.$(MODULE_EXT)
genjs.$(MODULE_EXT): type.$(MODULE_EXT) optimizer.$(MODULE_EXT) lexer.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) ast.$(MODULE_EXT)
genneko.$(MODULE_EXT): type.$(MODULE_EXT) lexer.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) ast.$(MODULE_EXT)
genphp.$(MODULE_EXT): type.$(MODULE_EXT) lexer.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) ast.$(MODULE_EXT)
genpy.$(MODULE_EXT): type.$(MODULE_EXT) lexer.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) ast.$(MODULE_EXT)
genswf.$(MODULE_EXT): type.$(MODULE_EXT) genswf9.$(MODULE_EXT) common.$(MODULE_EXT) ast.$(MODULE_EXT)
genswf9.$(MODULE_EXT): type.$(MODULE_EXT) lexer.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) ast.$(MODULE_EXT)
genxml.$(MODULE_EXT): type.$(MODULE_EXT) lexer.$(MODULE_EXT) common.$(MODULE_EXT) ast.$(MODULE_EXT)
interp.$(MODULE_EXT): typecore.$(MODULE_EXT) type.$(MODULE_EXT) lexer.$(MODULE_EXT) genneko.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) ast.$(MODULE_EXT) genswf.$(MODULE_EXT) genjava.$(MODULE_EXT) gencs.$(MODULE_EXT) parser.$(MODULE_EXT) libs/ilib/il.$(LIB_EXT)
matcher.$(MODULE_EXT): optimizer.$(MODULE_EXT) codegen.$(MODULE_EXT) typecore.$(MODULE_EXT) type.$(MODULE_EXT) typer.$(MODULE_EXT) common.$(MODULE_EXT) ast.$(MODULE_EXT)
main.$(MODULE_EXT): filters.$(MODULE_EXT) matcher.$(MODULE_EXT) typer.$(MODULE_EXT) typeload.$(MODULE_EXT) typecore.$(MODULE_EXT) type.$(MODULE_EXT) parser.$(MODULE_EXT) optimizer.$(MODULE_EXT) lexer.$(MODULE_EXT) interp.$(MODULE_EXT) genxml.$(MODULE_EXT) genswf.$(MODULE_EXT) genphp.$(MODULE_EXT) genneko.$(MODULE_EXT) genjs.$(MODULE_EXT) gencpp.$(MODULE_EXT) genas3.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) ast.$(MODULE_EXT) gencommon.$(MODULE_EXT) genjava.$(MODULE_EXT) gencs.$(MODULE_EXT) genpy.$(MODULE_EXT) version.$(MODULE_EXT) libs/ilib/il.$(LIB_EXT)
optimizer.$(MODULE_EXT): typecore.$(MODULE_EXT) type.$(MODULE_EXT) parser.$(MODULE_EXT) common.$(MODULE_EXT) ast.$(MODULE_EXT)
parser.$(MODULE_EXT): parser.ml lexer.$(MODULE_EXT) common.$(MODULE_EXT) ast.$(MODULE_EXT)
$(CC_PARSER_CMD)
type.$(MODULE_EXT): ast.$(MODULE_EXT)
typecore.$(MODULE_EXT): type.$(MODULE_EXT) common.$(MODULE_EXT) ast.$(MODULE_EXT)
typeload.$(MODULE_EXT): typecore.$(MODULE_EXT) type.$(MODULE_EXT) parser.$(MODULE_EXT) optimizer.$(MODULE_EXT) lexer.$(MODULE_EXT) common.$(MODULE_EXT) ast.$(MODULE_EXT)
typer.$(MODULE_EXT): typeload.$(MODULE_EXT) typecore.$(MODULE_EXT) type.$(MODULE_EXT) parser.$(MODULE_EXT) optimizer.$(MODULE_EXT) lexer.$(MODULE_EXT) interp.$(MODULE_EXT) genneko.$(MODULE_EXT) genjs.$(MODULE_EXT) common.$(MODULE_EXT) codegen.$(MODULE_EXT) ast.$(MODULE_EXT) filters.$(MODULE_EXT) gencommon.$(MODULE_EXT)
lexer.$(MODULE_EXT): lexer.ml
lexer.$(MODULE_EXT): ast.$(MODULE_EXT)
ast.$(MODULE_EXT):
version.$(MODULE_EXT):
$(MAKE) -f Makefile.version_extra -s ADD_REVISION=$(ADD_REVISION) BRANCH=$(BRANCH) COMMIT_SHA=$(COMMIT_SHA) COMMIT_DATE=$(COMMIT_DATE) > version.ml
$(COMPILER) $(CFLAGS) -c version.ml
# Package
package_bin:
mkdir -p out
rm -rf $(PACKAGE_FILE_NAME) $(PACKAGE_FILE_NAME).tar.gz
# Copy the package contents to $(PACKAGE_FILE_NAME)
mkdir -p $(PACKAGE_FILE_NAME)
cp -r $(OUTPUT) haxelib$(EXTENSION) std extra/LICENSE.txt extra/CONTRIB.txt extra/CHANGES.txt $(PACKAGE_FILE_NAME)
# archive
tar -zcf out/$(PACKAGE_FILE_NAME).tar.gz $(PACKAGE_FILE_NAME)
rm -r $(PACKAGE_FILE_NAME)
# Clean
clean: clean_libs clean_haxe clean_tools
clean_libs:
make -C libs/extlib clean
make -C libs/extc clean
make -C libs/neko clean
make -C libs/ziplib clean
make -C libs/javalib clean
make -C libs/ilib clean
make -C libs/swflib clean
make -C libs/xml-light clean
make -C libs/ttflib clean
make -C libs/objsize clean
clean_haxe:
rm -f $(MODULES:=.obj) $(MODULES:=.o) $(MODULES:=.cmx) $(MODULES:=.cmi) $(MODULES:=.cmo) lexer.ml $(OUTPUT)
clean_tools:
rm -f $(OUTPUT) haxelib
# SUFFIXES
.ml.cmx:
$(CC_CMD)
.ml.cmo:
$(CC_CMD)
.mll.ml:
ocamllex $<
.PHONY: haxe libs version.cmx version.cmo haxelib
haxe_3.2.1+dfsg.orig/Makefile.version_extra 0000664 0001750 0001750 00000000666 12607337712 020663 0 ustar andy andy 0000000 0000000 # A hack to print the content of version.ml consistently across Windows (cygwin / command prompt) and Unix.
# The hack: http://stackoverflow.com/a/7284135/267998
# The issue: https://github.com/HaxeFoundation/haxe/commit/4f8f6a99ddf810ea045492cdd6d40c55abc03e15#commitcomment-10660400
all: ;
ifneq ($(ADD_REVISION),0)
$(info let version_extra = Some "(git build $(BRANCH) @ $(COMMIT_SHA))")
else
$(info let version_extra = None)
endif haxe_3.2.1+dfsg.orig/Makefile.win 0000664 0001750 0001750 00000003244 12607337712 016563 0 ustar andy andy 0000000 0000000 include Makefile
OUTPUT=haxe.exe
EXTENSION=.exe
OCAMLOPT=ocamlopt.opt
kill:
-@taskkill /F /IM haxe.exe
# allow Ocaml/Mingw as well
NATIVE_LIBS += -I "c:/program files/mingw/lib/"
# use make WODI=wodi32 -f Makefile.win to build using WODI 32bit
ifdef WODI
NATIVE_LIBS += -I "/opt/${WODI}/lib"
endif
# use make MSVC=1 -f Makefile.win to build for OCaml/MSVC
ifeq (${MSVC}, 1)
NATIVE_LIBS = shell32.lib libs/extc/extc_stubs.obj libs/extc/process_stubs.obj libs/extc/zlib/zlib.lib libs/objsize/c_objsize.obj
endif
ifeq (${MSVC_OUTPUT}, 1)
FILTER=sed 's/File "\([^"]\+\)", line \([0-9]\+\), \(.*\)/\1(\2): \3/' tmp.cmi
endif
ifeq (${FD_OUTPUT}, 1)
FILTER=sed '/File/{ N; s/File "\([^"]\+\)", line \([0-9]\+\), characters \([0-9-]\+\):[\r\n]*\(.*\)/\1:\2: characters \3 : \4/ }' tmp.cmi
endif
ifdef FILTER
CC_CMD=($(OCAMLOPT) $(CFLAGS) -c $< 2>tmp.cmi && $(FILTER)) || ($(FILTER) && exit 1)
CC_PARSER_CMD=($(OCAMLOPT) -pp camlp4o $(CFLAGS) -c parser.ml 2>tmp.cmi && $(FILTER)) || ($(FILTER) && exit 1)
endif
package_bin:
mkdir -p out
rm -rf $(PACKAGE_FILE_NAME) $(PACKAGE_FILE_NAME).zip temp.zip
# Copy the package contents to $(PACKAGE_FILE_NAME)
# Using poor man's cp (zip then unzip), because cp in cygwin is quite broken
mkdir -p $(PACKAGE_FILE_NAME)
7za a -y -tzip -mx0 temp.zip $(OUTPUT) haxelib$(EXTENSION) std > log.txt || type log.txt
cd extra && 7za a -y -tzip -mx0 ../temp.zip LICENSE.txt CONTRIB.txt CHANGES.txt > log.txt || type log.txt
7za x -y temp.zip -o$(PACKAGE_FILE_NAME) > log.txt || type log.txt
rm temp.zip
# archive
7za a -r -tzip out/$(PACKAGE_FILE_NAME).zip $(PACKAGE_FILE_NAME) > log.txt || type log.txt
rm -r $(PACKAGE_FILE_NAME)
rm log.txt extra/log.txt haxe_3.2.1+dfsg.orig/README.md 0000664 0001750 0001750 00000007652 12607337712 015615 0 ustar andy andy 0000000 0000000
# [
](http://haxe.org) - [The Cross-Platform Toolkit](http://haxe.org)
[](https://travis-ci.org/HaxeFoundation/haxe)
[](https://ci.appveyor.com/project/HaxeFoundation/haxe)
[](https://saucelabs.com/u/haxe)
[](https://gitter.im/HaxeFoundation/haxe?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
Haxe is an open source toolkit that allows you to easily build cross-platform tools and applications that target many mainstream platforms. The Haxe toolkit includes:
* **The Haxe programming language**, a modern, high-level, strictly-typed programming language
* **The Haxe cross-compiler**, a state-of-the-art, lightning-speed compiler for many targets
* **The Haxe standard library**, a complete, cross-platform library of common functionality
Haxe allows you to compile for the following targets:
* ActionScript 3
* C++
* C#
* Flash
* Java
* JavaScript
* NekoVM
* PHP
* Python
You can try Haxe directly from your browser at [try.haxe.org](http://try.haxe.org)!
For more information about Haxe, head to the [offical Haxe website](http://haxe.org).
## License
The Haxe project has several licenses, covering different parts of the projects.
* The Haxe compiler is released under the GNU General Public License version 2 or any later version.
* The Haxe libraries are released under a "two-clause" BSD license.
* The Neko runtime is licensed under the GNU Lesser General Public License version 2.1 or any later version.
For the complete Haxe licenses, please see http://haxe.org/foundation/open-source.html or [extra/LICENSE.txt](extra/LICENSE.txt).
## Installing Haxe
The latest stable release is [Haxe 3.2.0-rc2](http://haxe.org/download/version/3.2.0-rc.2/). Pre-built binaries are available for your platform:
* **[Windows installer](http://haxe.org/download/file/3.2.0-rc.2/haxe-3.2.0-rc2-win.exe)**
* **[Windows binaries](http://haxe.org/download/file/3.2.0-rc.2/haxe-3.2.0-rc2-win.zip)**
* **[OSX installer](http://haxe.org/download/file/3.2.0-rc.2/haxe-3.2.0-rc2-osx-installer.pkg)**
* **[OSX binaries](http://haxe.org/download/file/3.2.0-rc.2/haxe-3.2.0-rc2-osx.tar.gz)**
* **[Linux 32-bit binaries](http://haxe.org/download/file/3.2.0-rc.2/haxe-3.2.0-rc2-linux32.tar.gz)**
* **[Linux 64-bit binaries](http://haxe.org/download/file/3.2.0-rc.2/haxe-3.2.0-rc2-linux64.tar.gz)**
Automated development builds are available from [build.haxe.org](http://build.haxe.org).
## Building from source
1. Clone the repository using git. Be sure to initialize and fetch the submodules.
git clone --recursive git://github.com/HaxeFoundation/haxe.git
cd haxe
2. Follow the [documentation on building Haxe for your platform](http://haxe.org/documentation/introduction/building-haxe.html).
## Using Haxe
For information on on using Haxe, consult the [Haxe documentation](http://haxe.org/documentation):
* [Haxe Introduction](http://haxe.org/documentation/introduction), an introduction to the Haxe toolkit
* [The Haxe Manual](http://haxe.org/manual), the reference manual for the Haxe language
* [Haxe API](http://api.haxe.org), documentation for the Haxe standard and native APIs
* [Haxelib](http://lib.haxe.org), a repository of Haxe libraries for a variety of needs
## Community
You can get help and talk with fellow Haxers from around the world via:
* the [official Haxe Google Group](https://groups.google.com/forum/#!forum/haxelang)
* the [Haxe IRC chatroom](http://unic0rn.github.io/tiramisu/haxe), #haxe on chat.freenode.net
## Version compatibility
Haxe | neko
---- | -----
2.* | 1.*
3.0.0 | 2.0.0
3.1.3 | 2.0.0
haxe_3.2.1+dfsg.orig/analyzer.ml 0000664 0001750 0001750 00000142103 12607337712 016504 0 ustar andy andy 0000000 0000000 open Ast
open Type
open Common
open Typecore
let s_expr = s_expr (s_type (print_context()))
let s_expr_pretty = s_expr_pretty "" (s_type (print_context()))
let debug e = print_endline (s_expr e)
let debug_pretty s e = Printf.printf "%s %s\n" s (s_expr_pretty e)
let flag_no_check = "no_check"
let flag_check = "check"
let flag_no_const_propagation = "no_const_propagation"
let flag_const_propagation = "const_propagation"
let flag_no_local_dce = "no_local_dce"
let flag_local_dce = "local_dce"
let flag_ignore = "ignore"
let flag_no_simplification = "no_simplification"
let flag_check_has_effect = "check_has_effect"
let flag_no_check_has_effect = "no_check_has_effect"
let has_analyzer_option meta s =
try
let rec loop ml = match ml with
| (Meta.Analyzer,el,_) :: ml ->
if List.exists (fun (e,p) ->
match e with
| EConst(Ident s2) when s = s2 -> true
| _ -> false
) el then
true
else
loop ml
| _ :: ml ->
loop ml
| [] ->
false
in
loop meta
with Not_found ->
false
let is_ignored meta =
try
let rec loop ml = match ml with
| (Meta.Analyzer,el,_) :: ml ->
if List.exists (fun (e,p) ->
match e with
| EConst(Ident s2) when flag_ignore = s2 -> true
| _ -> false
) el then
true
else
loop ml
| (Meta.HasUntyped,_,_) :: _ ->
true
| _ :: ml ->
loop ml
| [] ->
false
in
loop meta
with Not_found ->
false
let rec get_type_meta t = match t with
| TMono r ->
begin match !r with
| None -> raise Not_found
| Some t -> get_type_meta t
end
| TLazy f ->
get_type_meta (!f())
| TInst(c,_) ->
c.cl_meta
| TEnum(en,_) ->
en.e_meta
| TAbstract(a,_) ->
a.a_meta
| TType(t,_) ->
t.t_meta
| TAnon _ | TFun _ | TDynamic _ ->
raise Not_found
let type_has_analyzer_option t s =
try
has_analyzer_option (get_type_meta t) s
with Not_found ->
false
let is_enum_type t = match follow t with
| TEnum(_) -> true
| _ -> false
let rec awkward_get_enum_index com e = match e.eexpr with
| TArray(e1,{eexpr = TConst(TInt i)}) when com.platform = Js && Int32.to_int i = 1 && is_enum_type e1.etype ->
e1
| TCall({eexpr = TField(e1, FDynamic "__Index")},[]) when com.platform = Cpp && is_enum_type e1.etype ->
e1
| TField(e1,FDynamic "index") when com.platform = Neko && is_enum_type e1.etype ->
e1
| TParenthesis e1 | TCast(e1,None) | TMeta(_,e1) ->
awkward_get_enum_index com e1
| _ ->
raise Not_found
(*
This module simplifies the AST by introducing temporary variables for complex expressions in many places.
In particular, it ensures that no branching can occur in value-places so that we can later insert SSA PHI
nodes without worrying about their placement.
*)
module Simplifier = struct
let mk_block_context com =
let block_el = ref [] in
let push e = block_el := e :: !block_el in
let assign ev e =
let mk_assign e2 = match e2.eexpr with
| TBreak | TContinue | TThrow _ | TReturn _ -> e2
| _ -> mk (TBinop(OpAssign,ev,e2)) e2.etype e2.epos
in
let rec loop e = match e.eexpr with
| TBlock el ->
begin match List.rev el with
| e1 :: el ->
let el = List.rev ((loop e1) :: el) in
{e with eexpr = TBlock el}
| _ ->
mk_assign e
end
| TIf(e1,e2,eo) ->
let e2 = loop e2 in
let eo = match eo with None -> None | Some e3 -> Some (loop e3) in
{e with eexpr = TIf(e1,e2,eo)}
| TSwitch(e1,cases,edef) ->
let cases = List.map (fun (el,e) ->
let e = loop e in
el,e
) cases in
let edef = match edef with None -> None | Some edef -> Some (loop edef) in
{e with eexpr = TSwitch(e1,cases,edef)}
| TTry(e1,catches) ->
let e1 = loop e1 in
let catches = List.map (fun (v,e) ->
let e = loop e in
v,e
) catches in
{e with eexpr = TTry(e1,catches)}
| TParenthesis e1 | TMeta(_,e1) ->
loop e1 (* this is still weird, have to review *)
(* | TBinop(OpAssign,({eexpr = TLocal _} as e1),e2) ->
push e;
mk_assign e1 *)
(* | TBinop(OpAssignOp op,({eexpr = TLocal _} as e1),e2) ->
push e;
mk_assign e1 *)
| _ ->
mk_assign e
in
loop e
in
let declare_temp t eo p =
let v = alloc_var "tmp" t in
v.v_meta <- [Meta.CompilerGenerated,[],p];
let e_v = mk (TLocal v) t p in
let declare e_init =
let e = mk (TVar (v,e_init)) com.basic.tvoid p in
push e;
in
let e_v = match eo with
| None ->
declare None;
e_v
| Some e1 ->
begin match e1.eexpr with
| TThrow _ | TReturn _ | TBreak | TContinue ->
e1
| _ ->
let rec loop e_v e = match e.eexpr with
| TParenthesis e1 ->
loop {e_v with eexpr = TParenthesis e_v} e1
| TMeta(m,e1) ->
loop {e_v with eexpr = TMeta(m,e_v)} e1
| _ ->
e_v,e
in
let e_v',e1 = loop e_v e1 in
let e1 = assign e_v e1 in
begin match e1.eexpr with
| TBinop(OpAssign,{eexpr = TLocal v1},e2) when v == v1 ->
declare (Some e2)
| _ ->
declare None;
push e1
end;
e_v'
end
in
e_v
in
let rec push_block () =
let cur = !block_el in
block_el := [];
fun () ->
let added = !block_el in
block_el := cur;
List.rev added
and block f el =
let close = push_block() in
List.iter (fun e ->
push (f e)
) el;
close()
in
block,declare_temp,fun () -> !block_el
let apply com e =
let block,declare_temp,close_block = mk_block_context com in
let skip_binding ?(allow_tlocal=false) e =
let rec loop e =
match e.eexpr with
| TConst _ | TTypeExpr _ | TFunction _ -> ()
| TLocal _ when allow_tlocal -> ()
| TParenthesis e1 | TCast(e1,None) -> Type.iter loop e
| TField(_,(FStatic(c,cf) | FInstance(c,_,cf))) when has_analyzer_option cf.cf_meta flag_no_simplification || has_analyzer_option c.cl_meta flag_no_simplification -> ()
| TField({eexpr = TLocal _},_) when allow_tlocal -> ()
| TCall({eexpr = TField(_,(FStatic(c,cf) | FInstance(c,_,cf)))},el) when has_analyzer_option cf.cf_meta flag_no_simplification || has_analyzer_option c.cl_meta flag_no_simplification -> ()
| TCall({eexpr = TLocal { v_name = "__cpp__" } },_) -> ()
| TField(_,FEnum _) -> ()
| TField(_,FDynamic _) -> ()
| _ when (try ignore(awkward_get_enum_index com e); true with Not_found -> false) -> ()
| _ -> raise Exit
in
try
loop e;
true
with Exit ->
begin match follow e.etype with
| TAbstract({a_path = [],"Void"},_) -> true
| TInst ({ cl_path = [],"Array" }, _) when com.platform = Cpp -> true
| _ -> false
end
in
let has_unbound = ref false in
let rec loop e = match e.eexpr with
| TCall({eexpr = TLocal v | TField({eexpr = TLocal v},_)},_) | TField({eexpr = TLocal v},_) | TLocal v when Meta.has Meta.Unbound v.v_meta && v.v_name <> "`trace" ->
has_unbound := true;
e
| TBlock el ->
{e with eexpr = TBlock (block loop el)}
| TCall({eexpr = TField(_,(FStatic(c,cf) | FInstance(c,_,cf)))},el) when has_analyzer_option cf.cf_meta flag_no_simplification || has_analyzer_option c.cl_meta flag_no_simplification ->
e
| TField(_,(FStatic(c,cf) | FInstance(c,_,cf))) when has_analyzer_option cf.cf_meta flag_no_simplification || has_analyzer_option c.cl_meta flag_no_simplification ->
e
| TCall(e1,el) ->
let rec is_valid_call_target e = match e.eexpr with
| TFunction _ | TField _ | TLocal _ | TConst (TSuper) ->
true
| TParenthesis e1 | TCast(e1,None) | TMeta(_,e1) ->
is_valid_call_target e1
| _ ->
false
in
let e1 = if is_valid_call_target e1 then
loop e1
else
bind e1
in
let check e t =
if type_has_analyzer_option t flag_no_simplification then e
else bind e
in
let el = match e1.eexpr,follow e1.etype with
| TConst TSuper,_ when com.platform = Java || com.platform = Cs ->
(* they hate you if you mess up the super call *)
el
| _,TFun _ | TConst TSuper,_ ->
Codegen.UnificationCallback.check_call check el e1.etype
| _ ->
(* too dangerous *)
List.map loop el
in
{e with eexpr = TCall(e1,el)}
| TNew(c,tl,el) ->
{e with eexpr = TNew(c,tl,ordered_list el)}
| TArrayDecl el ->
{e with eexpr = TArrayDecl (ordered_list el)}
| TObjectDecl fl ->
let el = ordered_list (List.map snd fl) in
{e with eexpr = TObjectDecl (List.map2 (fun (n,_) e -> n,e) fl el)}
| TBinop(OpBoolAnd | OpBoolOr as op,e1,e2) ->
let e1 = loop e1 in
let e_then = mk (TBlock (block loop [e2])) e2.etype e2.epos in
let e_if,e_else = if op = OpBoolOr then
mk (TUnop(Not,Prefix,e1)) com.basic.tbool e.epos,mk (TConst (TBool(true))) com.basic.tbool e.epos
else
e1,mk (TConst (TBool(false))) com.basic.tbool e.epos
in
loop (mk (TIf(e_if,e_then,Some e_else)) com.basic.tbool e.epos)
| TBinop((OpAssign | OpAssignOp _) as op,{eexpr = TArray(e11,e12)},e2) ->
let e1 = match ordered_list [e11;e12] with
| [e1;e2] ->
{e with eexpr = TArray(e1,e2)}
| _ ->
assert false
in
let e2 = bind e2 in
{e with eexpr = TBinop(op,e1,e2)}
| TBinop((OpAssign | OpAssignOp _) as op,e1,e2) ->
let e2 = bind ~allow_tlocal:true e2 in
let e1 = loop e1 in
{e with eexpr = TBinop(op,e1,e2)}
| TBinop(op,e1,e2) ->
begin match ordered_list [e1;e2] with
| [e1;e2] ->
{e with eexpr = TBinop(op,e1,e2)}
| _ ->
assert false
end
| TArray(e1,e2) ->
begin match ordered_list [e1;e2] with
| [e1;e2] ->
{e with eexpr = TArray(e1,e2)}
| _ ->
assert false
end
| TWhile(e1,e2,flag) when (match e1.eexpr with TConst(TBool true) | TParenthesis {eexpr = TConst(TBool true)} -> false | _ -> true) ->
let p = e.epos in
let e_break = mk TBreak t_dynamic p in
let e_not = mk (TUnop(Not,Prefix,Codegen.mk_parent e1)) e1.etype e1.epos in
let e_if eo = mk (TIf(e_not,e_break,eo)) com.basic.tvoid p in
let rec map_continue e = match e.eexpr with
| TContinue ->
(e_if (Some e))
| TWhile _ | TFor _ ->
e
| _ ->
Type.map_expr map_continue e
in
let e2 = if flag = NormalWhile then e2 else map_continue e2 in
let e_if = e_if None in
let e_if = mk (TMeta((Meta.Custom ":whileCond",[],e_if.epos), e_if)) e_if.etype e_if.epos in
let e_block = if flag = NormalWhile then Type.concat e_if e2 else Type.concat e2 e_if in
let e_true = mk (TConst (TBool true)) com.basic.tbool p in
let e = mk (TWhile(Codegen.mk_parent e_true,e_block,NormalWhile)) e.etype p in
loop e
| TFor(v,e1,e2) ->
let e1 = bind e1 in
let e2 = loop e2 in
{e with eexpr = TFor(v,e1,e2)}
| TIf(e1,e2,eo) ->
let e1 = bind e1 in
let e2 = loop e2 in
let eo = match eo with None -> None | Some e -> Some (loop e) in
{e with eexpr = TIf(e1,e2,eo)}
| TSwitch (e1,cases,eo) ->
let e1 = bind e1 in
let cases = List.map (fun (el,e) ->
let el = List.map loop el in
let e = loop e in
el,e
) cases in
let eo = match eo with None -> None | Some e -> Some (loop e) in
{e with eexpr = TSwitch(e1,cases,eo)}
| TVar(v,Some e1) ->
let e1 = match e1.eexpr with
| TFunction _ -> loop e1
| TArrayDecl [{eexpr = TFunction _}] -> loop e1
| _ -> bind ~allow_tlocal:true e1
in
{e with eexpr = TVar(v,Some e1)}
| TUnop((Neg | NegBits | Not) as op,flag,e1) ->
let e1 = bind e1 in
{e with eexpr = TUnop(op,flag,e1)}
| TField(e1,fa) ->
let e1 = bind ~allow_tlocal:true e1 in
{e with eexpr = TField(e1,fa)}
| TReturn (Some ({eexpr = TThrow _ | TReturn _} as e1)) ->
loop e1 (* this is a bit hackish *)
| TReturn (Some e1) ->
let e1 = bind e1 in
{e with eexpr = TReturn (Some e1)}
| TThrow e1 ->
let e1 = bind e1 in
{e with eexpr = TThrow e1}
| TCast(e1,mto) ->
let e1 = bind ~allow_tlocal:true e1 in
{e with eexpr = TCast(e1,mto)}
| _ ->
Type.map_expr loop e
and bind ?(allow_tlocal=false) e =
let e = loop e in
if skip_binding ~allow_tlocal e then
e
else
declare_temp e.etype (Some e) e.epos
and ordered_list el =
if List.for_all (skip_binding ~allow_tlocal:true) el then
List.map loop el
else
List.map bind el
in
let e = loop e in
!has_unbound,match close_block() with
| [] ->
e
| el ->
mk (TBlock (List.rev (e :: el))) e.etype e.epos
let unapply com e =
let var_map = ref IntMap.empty in
let rec get_assignment_to v e = match e.eexpr with
| TBinop(OpAssign,{eexpr = TLocal v2},e2) when v == v2 -> Some e2
| TBlock [e] -> get_assignment_to v e
| TIf(e1,e2,Some e3) ->
begin match get_assignment_to v e2,get_assignment_to v e3 with
| Some e2,Some e3 -> Some ({e with eexpr = TIf(e1,e2,Some e3)})
| _ -> None
end
| _ -> None
in
let if_or_op e e1 e2 e3 = match e1.eexpr,e3.eexpr with
| TUnop(Not,Prefix,e1),TConst (TBool true) -> {e with eexpr = TBinop(OpBoolOr,e1,e2)}
| _,TConst (TBool false) -> {e with eexpr = TBinop(OpBoolAnd,e1,e2)}
| _ -> {e with eexpr = TIf(e1,e2,Some e3)}
in
let rec loop e = match e.eexpr with
| TBlock el ->
let rec loop2 el = match el with
| e :: el ->
begin match e.eexpr with
| TVar(v,Some e1) when Meta.has Meta.CompilerGenerated v.v_meta ->
if el = [] then
[loop e1]
else begin
var_map := IntMap.add v.v_id (loop e1) !var_map;
loop2 el
end
| TVar(v,None) when not (com.platform = Php) ->
begin match el with
| {eexpr = TBinop(OpAssign,{eexpr = TLocal v2},e2)} :: el when v == v2 ->
let e = {e with eexpr = TVar(v,Some e2)} in
loop2 (e :: el)
| ({eexpr = TIf(e1,e2,Some e3)} as e_if) :: el ->
let e1 = loop e1 in
let e2 = loop e2 in
let e3 = loop e3 in
begin match get_assignment_to v e2,get_assignment_to v e3 with
| Some e2,Some e3 ->
let e_if = if_or_op e_if (loop e1) (loop e2) (loop e3) in
let e = {e with eexpr = TVar(v,Some e_if)} in
loop2 (e :: el)
| _ ->
let e_if = {e_if with eexpr = TIf(e1,e2,Some e3)} in
e :: e_if :: loop2 el
end
| _ ->
let e = loop e in
e :: loop2 el
end
| TReturn (Some e1) when (match follow e1.etype with TAbstract({a_path=[],"Void"},_) -> true | _ -> false) ->
[(loop e1);{e with eexpr = TReturn None}]
| _ ->
let e = loop e in
e :: loop2 el
end
| [] ->
[]
in
let el = loop2 el in
{e with eexpr = TBlock el}
| TLocal v when Meta.has Meta.CompilerGenerated v.v_meta ->
begin try IntMap.find v.v_id !var_map
with Not_found -> e end
| TWhile(e1,e2,flag) ->
let e1 = loop e1 in
let e2 = loop e2 in
let extract_cond e = match e.eexpr with
| TIf({eexpr = TUnop(Not,_,e1)},_,_) -> e1
| TBreak -> raise Exit (* can happen due to optimization, not so easy to deal with because there might be other breaks/continues *)
| _ -> assert false
in
let e1,e2,flag = try
begin match e2.eexpr with
| TBlock el ->
begin match el with
| {eexpr = TMeta((Meta.Custom ":whileCond",_,_),e1)} :: el ->
let e1 = extract_cond e1 in
e1,{e2 with eexpr = TBlock el},NormalWhile
| _ ->
e1,e2,flag
(* issue 3844 *)
(* begin match List.rev el with
| {eexpr = TMeta((Meta.Custom ":whileCond",_,_),e1)} :: el ->
let e1 = extract_cond e1 in
e1,{e2 with eexpr = TBlock (List.rev el)},DoWhile
| _ ->
e1,e2,flag
end *)
end
| _ ->
e1,e2,flag
end with Exit ->
e1,e2,flag
in
{e with eexpr = TWhile(e1,e2,flag)}
| TIf(e1,e2,Some e3) ->
let e1 = loop e1 in
let e2 = loop e2 in
let e3 = loop e3 in
if_or_op e e1 e2 e3
| _ ->
Type.map_expr loop e
in
loop e
end
module Ssa = struct
type var_map = tvar IntMap.t
type condition =
| Equal of tvar * texpr
| NotEqual of tvar * texpr
type node_data = {
nd_pos: pos;
mutable nd_var_map : var_map;
mutable nd_terminates : bool;
}
type join_node = {
mutable branches : node_data list;
}
type ssa_context = {
com : Common.context;
mutable cleanup : (unit -> unit) list;
mutable cur_data : node_data;
mutable var_conds : (condition list) IntMap.t;
mutable loop_stack : (join_node * join_node) list;
mutable exception_stack : join_node list;
mutable block_depth : int;
}
let s_cond = function
| Equal(v,e) -> Printf.sprintf "%s == %s" v.v_name (s_expr_pretty e)
| NotEqual(v,e) -> Printf.sprintf "%s != %s" v.v_name (s_expr_pretty e)
let s_conds conds =
String.concat " && " (List.map s_cond conds)
let mk_loc v p = mk (TLocal v) v.v_type p
let mk_phi =
let v_phi = alloc_var "__ssa_phi__" t_dynamic in
(fun vl p ->
let e = mk (TCall(mk_loc v_phi p,(List.map (fun (v,p) -> mk_loc v p) vl))) t_dynamic p in
e
)
(* TODO: make sure this is conservative *)
let can_throw e =
let rec loop e = match e.eexpr with
| TConst _ | TLocal _ | TTypeExpr _ | TFunction _ | TBlock _ -> ()
| TCall _ | TNew _ | TThrow _ | TCast(_,Some _) -> raise Exit
| _ -> Type.iter loop e
in
try
loop e; false
with Exit ->
true
let mk_join_node() = {
branches = []
}
let mk_node_data p = {
nd_pos = p;
nd_var_map = IntMap.empty;
nd_terminates = false;
}
let add_branch join branch p =
join.branches <- {branch with nd_pos = p} :: join.branches
let branch ctx p =
let old_map = ctx.cur_data.nd_var_map in
let old_term = ctx.cur_data.nd_terminates in
ctx.cur_data.nd_terminates <- false;
(fun join ->
add_branch join ctx.cur_data p;
ctx.cur_data.nd_var_map <- old_map;
ctx.cur_data.nd_terminates <- old_term;
)
let terminate ctx =
ctx.cur_data.nd_terminates <- true
let set_loop_join ctx join_top join_bottom =
ctx.loop_stack <- (join_top,join_bottom) :: ctx.loop_stack;
(fun () ->
ctx.loop_stack <- List.tl ctx.loop_stack
)
let set_exception_join ctx join =
ctx.exception_stack <- join :: ctx.exception_stack;
(fun () ->
ctx.exception_stack <- List.tl ctx.exception_stack;
)
let create_v_extra v =
match v.v_extra with
| Some (_,Some _) ->
()
| Some (tl,None) ->
let e_extra = mk (TObjectDecl []) t_dynamic null_pos in
v.v_extra <- Some (tl,Some e_extra)
| None ->
let e_extra = mk (TObjectDecl []) t_dynamic null_pos in
v.v_extra <- Some ([],Some e_extra)
let set_v_extra_value v s e = match v.v_extra with
| Some (tl, Some {eexpr = TObjectDecl fl}) ->
let rec loop fl = match fl with
| (s',_) :: fl when s' = s ->
(s,e) :: fl
| f1 :: fl ->
f1 :: loop fl
| [] ->
[s,e]
in
let e_extra = mk (TObjectDecl (loop fl)) t_dynamic null_pos in
v.v_extra <- Some (tl, Some e_extra)
| _ ->
assert false
let get_origin_var v = match v.v_extra with
| Some (_,Some {eexpr = TObjectDecl fl}) ->
begin match List.assoc "origin_var" fl with
| {eexpr = TLocal v'} -> v'
| _ -> raise Not_found
end
| _ ->
raise Not_found
let set_origin_var v v_origin p =
let ev = mk_loc v_origin p in
set_v_extra_value v "origin_var" ev
let get_var_value v = match v.v_extra with
| Some (_,Some {eexpr = TObjectDecl fl}) ->
List.assoc "var_value" fl
| _ ->
raise Not_found
let set_var_value v e =
set_v_extra_value v "var_value" e
let get_var_usage_count v = match v.v_extra with
| Some (_,Some {eexpr = TObjectDecl fl}) ->
begin try
begin match List.assoc "usage_count" fl with
| {eexpr = TConst (TInt i32)} -> Int32.to_int i32
| _ -> 0
end
with Not_found ->
0
end
| _ ->
raise Not_found
let set_var_usage_count v i =
let e = mk (TConst (TInt (Int32.of_int i))) t_dynamic null_pos in
set_v_extra_value v "usage_count" e
let declare_var ctx v p =
let old = v.v_extra in
ctx.cleanup <- (fun () ->
v.v_extra <- old
) :: ctx.cleanup;
ctx.cur_data.nd_var_map <- IntMap.add v.v_id v ctx.cur_data.nd_var_map;
v.v_meta <- ((Meta.Custom ":blockDepth",[EConst (Int (string_of_int ctx.block_depth)),p],p)) :: v.v_meta;
v.v_extra <- None;
create_v_extra v;
set_origin_var v v p
let assign_var ctx v e p =
if v.v_capture then
v
else begin
let i = match v.v_extra with
| Some (l,eo) ->
v.v_extra <- Some (("",t_dynamic) :: l,eo);
List.length l + 1
| _ ->
error "Something went wrong" p
in
let v' = alloc_var (Printf.sprintf "%s<%i>" v.v_name i) v.v_type in
create_v_extra v';
v'.v_meta <- [(Meta.Custom ":ssa"),[],p];
set_origin_var v' v p;
ctx.cur_data.nd_var_map <- IntMap.add v.v_id v' ctx.cur_data.nd_var_map;
set_var_value v' e;
v'
end
let get_var ctx v p =
try
IntMap.find v.v_id ctx.cur_data.nd_var_map
with Not_found ->
if not (has_meta Meta.Unbound v.v_meta) then
error (Printf.sprintf "Unbound variable %s" v.v_name) p;
v
let close_join_node ctx node p =
let terminates = ref true in
let branches = List.filter (fun branch ->
if branch.nd_terminates then false
else begin
terminates := false;
true
end
) node.branches in
match branches with
| [] ->
()
| branch :: branches ->
let vars = ref (IntMap.map (fun v -> [v,branch.nd_pos]) branch.nd_var_map) in
let rec handle_branch branch =
IntMap.iter (fun i v ->
try
let vl = IntMap.find i !vars in
if not (List.exists (fun (v',_) -> v == v') vl) then
vars := IntMap.add i ((v,p) :: vl) !vars
with Not_found ->
()
) branch.nd_var_map;
in
List.iter handle_branch branches;
ctx.cur_data.nd_terminates <- !terminates;
IntMap.iter (fun i vl -> match vl with
| [v,p] ->
ctx.cur_data.nd_var_map <- IntMap.add i v ctx.cur_data.nd_var_map;
| (v',_) :: _ ->
let v = get_origin_var v' in
ignore(assign_var ctx v (mk_phi vl p) p)
| _ ->
assert false
) !vars
let invert_cond = function
| Equal(v,e) -> NotEqual(v,e)
| NotEqual(v,e) -> Equal(v,e)
let invert_conds =
List.map invert_cond
let rec eval_cond ctx e = match e.eexpr with
| TBinop(OpNotEq,{eexpr = TLocal v},e1) ->
[NotEqual(v,e1)]
| TBinop(OpEq,{eexpr = TLocal v},e1) ->
[Equal(v,e1)]
| TUnop(Not,_,e1) ->
invert_conds (eval_cond ctx e1)
| TLocal v ->
begin try eval_cond ctx (get_var_value v)
with Not_found -> [] end
| _ ->
[]
let append_cond ctx v cond p =
begin try
let conds = IntMap.find v.v_id ctx.var_conds in
ctx.var_conds <- IntMap.add v.v_id (cond :: conds) ctx.var_conds
with Not_found ->
ctx.var_conds <- IntMap.add v.v_id [cond] ctx.var_conds
end
(* let apply_cond ctx = function
| Equal({v_extra = Some(_,Some {eexpr = TLocal v})} as v0,e1) ->
let v' = assign_var ctx v (mk_loc v0 e1.epos) e1.epos in
append_cond ctx v' (Equal(v',e1)) e1.epos
| NotEqual({v_extra = Some(_,Some {eexpr = TLocal v})} as v0,e1) ->
let v' = assign_var ctx v (mk_loc v0 e1.epos) e1.epos in
append_cond ctx v' (NotEqual(v',e1)) e1.epos
| _ -> ()
let apply_not_null_cond ctx v p =
apply_cond ctx (NotEqual(v,(mk (TConst TNull) t_dynamic p))) *)
let apply com e =
let rec handle_if ctx f econd eif eelse =
let econd = loop ctx econd in
(* let cond = eval_cond ctx econd in *)
let join = mk_join_node() in
let close = branch ctx eif.epos in
(* List.iter (apply_cond ctx) cond; *)
let eif = loop ctx eif in
close join;
let eelse = match eelse with
| None ->
(* let cond = invert_conds cond in *)
(* List.iter (apply_cond ctx) cond; *)
add_branch join ctx.cur_data e.epos;
None
| Some e ->
let close = branch ctx e.epos in
(* let cond = invert_conds cond in *)
(* List.iter (apply_cond ctx) cond; *)
let eelse = loop ctx e in
close join;
Some eelse
in
close_join_node ctx join e.epos;
f econd eif eelse
and handle_loop_body ctx e =
let join_top = mk_join_node() in
let join_bottom = mk_join_node() in
let unset = set_loop_join ctx join_top join_bottom in
let close = branch ctx e.epos in
ignore(loop ctx e); (* TODO: I don't know if this is sane. *)
close join_top;
add_branch join_top ctx.cur_data e.epos;
close_join_node ctx join_top e.epos;
let ebody = loop ctx e in
ctx.cur_data.nd_terminates <- false;
unset();
close_join_node ctx join_bottom e.epos;
ebody
and loop ctx e = match e.eexpr with
(* var declarations *)
| TVar(v,eo) ->
declare_var ctx v e.epos;
let eo = match eo with
| None -> None
| Some e ->
let e = loop ctx e in
set_var_value v e;
Some e
in
{e with eexpr = TVar(v,eo)}
| TFunction tf ->
let close = branch ctx e.epos in
List.iter (fun (v,co) ->
declare_var ctx v e.epos;
(* match co with
| Some TNull when (match v.v_type with TType({t_path=["haxe"],"PosInfos"},_) -> false | _ -> true) -> ()
| _ -> apply_not_null_cond ctx v e.epos *)
) tf.tf_args;
let e' = loop ctx tf.tf_expr in
close (mk_join_node());
{e with eexpr = TFunction {tf with tf_expr = e'}}
(* var modifications *)
| TBinop(OpAssign,({eexpr = TLocal v} as e1),e2) when v.v_name <> "this" ->
let e2 = loop ctx e2 in
let _ = assign_var ctx v e2 e1.epos in
{e with eexpr = TBinop(OpAssign,e1,e2)}
| TBinop(OpAssignOp op,({eexpr = TLocal v} as e1),e2) ->
let e1 = loop ctx e1 in
let e2 = loop ctx e2 in
let e_op = mk (TBinop(op,e1,e2)) e.etype e.epos in
let _ = assign_var ctx v e_op e1.epos in
{e with eexpr = TBinop(OpAssignOp op,e1,e2)}
| TUnop((Increment | Decrement as op),flag,({eexpr = TLocal v} as e1)) ->
let op = match op with Increment -> OpAdd | Decrement -> OpSub | _ -> assert false in
let e_one = mk (TConst (TInt (Int32.of_int 1))) com.basic.tint e.epos in
let e1 = loop ctx e1 in
let e_op = mk (TBinop(op,e1,e_one)) e.etype e.epos in
let _ = assign_var ctx v e_op e1.epos in
e
(* var user *)
| TLocal v ->
let v = get_var ctx v e.epos in
{e with eexpr = TLocal v}
(* control flow *)
| TIf(econd,eif,eelse) ->
let f econd eif eelse = {e with eexpr = TIf(econd,eif,eelse)} in
handle_if ctx f econd eif eelse
| TSwitch(e1,cases,edef) ->
let e1 = loop ctx e1 in
let join = mk_join_node() in
let cases = List.map (fun (el,e) ->
let close = branch ctx e.epos in
let el = List.map (loop ctx) el in
let e = loop ctx e in
close join;
el,e
) cases in
let edef = match edef with
| Some e ->
let close = branch ctx e.epos in
let e = loop ctx e in
close join;
Some e
| None ->
begin match e1.eexpr with
| TMeta((Meta.Exhaustive,_,_),_)
| TParenthesis({eexpr = TMeta((Meta.Exhaustive,_,_),_)}) ->
()
| _ ->
add_branch join ctx.cur_data e.epos;
end;
None
in
close_join_node ctx join e.epos;
let e = {e with eexpr = TSwitch(e1,cases,edef)} in
e
| TWhile(econd,ebody,mode) ->
let econd = loop ctx econd in
let ebody = handle_loop_body ctx ebody in
let e = {e with eexpr = TWhile(econd,ebody,mode)} in
e
| TFor(v,e1,ebody) ->
declare_var ctx v e.epos;
(* apply_not_null_cond ctx v e1.epos; *)
let v' = IntMap.find v.v_id ctx.cur_data.nd_var_map in
let e1 = loop ctx e1 in
let ebody = handle_loop_body ctx ebody in
let e = {e with eexpr = TFor(v',e1,ebody)} in
e
| TTry(e1,catches) ->
let join_ex = mk_join_node() in
let join_bottom = mk_join_node() in
let unset = set_exception_join ctx join_ex in
let e1 = loop ctx e1 in
unset();
add_branch join_bottom ctx.cur_data e.epos;
close_join_node ctx join_ex e.epos;
let catches = List.map (fun (v,e) ->
declare_var ctx v e.epos;
(* apply_not_null_cond ctx v e.epos; *)
let close = branch ctx e.epos in
let e = loop ctx e in
close join_bottom;
v,e
) catches in
close_join_node ctx join_bottom e.epos;
let e = {e with eexpr = TTry(e1,catches)} in
e
| TBreak ->
begin match ctx.loop_stack with
| [] -> error "Break outside loop" e.epos
| (_,join) :: _ -> add_branch join ctx.cur_data e.epos
end;
terminate ctx;
e
| TContinue ->
begin match ctx.loop_stack with
| [] -> error "Continue outside loop" e.epos
| (join,_) :: _ -> add_branch join ctx.cur_data e.epos
end;
terminate ctx;
e
| TThrow e1 ->
let e1 = loop ctx e1 in
begin match ctx.exception_stack with
| join :: _ -> add_branch join ctx.cur_data e.epos
| _ -> ()
end;
terminate ctx;
{e with eexpr = TThrow e1}
| TReturn eo ->
let eo = match eo with None -> None | Some e -> Some (loop ctx e) in
terminate ctx;
{e with eexpr = TReturn eo}
| TBlock el ->
let rec loop2 el = match el with
| [] ->
[]
| e :: el ->
if ctx.cur_data.nd_terminates then begin
(* ctx.com.warning (Printf.sprintf "Unreachable code: %s" (s_expr_pretty e)) e.epos; *)
[]
end else
let e = loop ctx e in
e :: (loop2 el)
in
ctx.block_depth <- ctx.block_depth + 1;
let el = loop2 el in
ctx.block_depth <- ctx.block_depth - 1;
{e with eexpr = TBlock(el)}
| _ ->
begin match ctx.exception_stack with
| join :: _ when can_throw e -> add_branch join ctx.cur_data e.epos
| _ -> ()
end;
Type.map_expr (loop ctx) e
in
let ctx = {
com = com;
cur_data = mk_node_data e.epos;
var_conds = IntMap.empty;
loop_stack = [];
exception_stack = [];
cleanup = [];
block_depth = 0;
} in
let e = loop ctx e in
e,ctx
let unapply com e =
let rec loop e = match e.eexpr with
| TFor(v,e1,e2) when Meta.has (Meta.Custom ":ssa") v.v_meta ->
let v' = get_origin_var v in
let e1 = loop e1 in
let e2 = loop e2 in
{e with eexpr = TFor(v',e1,e2)}
| TLocal v when Meta.has (Meta.Custom ":ssa") v.v_meta ->
let v' = get_origin_var v in
{e with eexpr = TLocal v'}
| TBlock el ->
let rec filter e = match e.eexpr with
| TMeta((Meta.Custom ":ssa",_,_),_) ->
false
| _ ->
true
in
let el = List.filter filter el in
let el = List.map loop el in
{e with eexpr = TBlock el}
| _ ->
Type.map_expr loop e
in
loop e
end
module ConstPropagation = struct
open Ssa
let expr_eq e1 e2 = match e1.eexpr,e2.eexpr with
| TConst ct1, TConst ct2 ->
ct1 = ct2
| _ ->
false
let get_block_depth v = try
let i = match Meta.get (Meta.Custom ":blockDepth") v.v_meta with
| _,[EConst(Int s),_],_ -> int_of_string s
| _ -> raise Not_found
in
i
with Not_found ->
-1
let can_be_inlined com v0 e = type_iseq v0.v_type e.etype && match e.eexpr with
| TConst ct ->
begin match ct with
| TThis | TSuper -> false
(* Some targets don't like seeing null in certain places and won't even compile. We have to detect `if (x != null)
in order for this to work. *)
| TNull when (match com.platform with Php | Cpp -> true | _ -> false) -> false
| _ -> true
end
| TLocal v ->
not (Meta.has Meta.CompilerGenerated v.v_meta) &&
begin try
let v' = Ssa.get_origin_var v in
begin match v'.v_extra with
| Some ([],_) -> get_block_depth v <= get_block_depth v0
| _ -> false
end
with Not_found ->
false
end
| TEnumParameter _ when not (com.platform = Php) ->
Ssa.get_var_usage_count v0 <= 1
| _ ->
false
let semi_awkward_enum_value ssa e i = match e.eexpr with
| TCall({eexpr = TField(_,FEnum _)},el) -> (try List.nth el i with Failure _ -> raise Not_found)
| _ -> raise Not_found
let rec local ssa force v e =
begin try
if v.v_capture then raise Not_found;
if type_has_analyzer_option v.v_type flag_no_const_propagation then raise Not_found;
begin match follow v.v_type with
| TDynamic _ -> raise Not_found
| _ -> ()
end;
let e = Ssa.get_var_value v in
let old = v.v_extra in
v.v_extra <- None;
let e = value ssa force e in
v.v_extra <- old;
Ssa.set_var_value v e;
e
with Not_found ->
e
end
(* force must only be true if the value is not used in the output *)
and value ssa force e = match e.eexpr with
| TUnop((Increment | Decrement),_,_)
| TBinop(OpAssignOp _,_,_)
| TBinop(OpAssign,_,_) ->
e
| TBinop(op,e1,e2) ->
let e1 = value ssa force e1 in
let e2 = value ssa force e2 in
let e = {e with eexpr = TBinop(op,e1,e2)} in
let e' = Optimizer.optimize_binop e op e1 e2 in
if e == e' then
e
else
value ssa force e'
| TUnop(op,flag,e1) ->
let e1 = value ssa force e1 in
let e = {e with eexpr = TUnop(op,flag,e1)} in
let e' = Optimizer.optimize_unop e op flag e1 in
if e == e' then
e
else
value ssa force e'
| TCall (({eexpr = TLocal {v_name = "__ssa_phi__"}} as ephi),el) ->
let el = List.map (value ssa force) el in
begin match el with
| [] -> assert false
| e1 :: el ->
if List.for_all (fun e2 -> expr_eq e1 e2) el then
value ssa force e1
else
{e with eexpr = TCall(ephi, e1 :: el)}
end
| TParenthesis e1 | TMeta(_,e1) ->
value ssa force e1
| TLocal v ->
let e' = local ssa force v e in
if force || can_be_inlined ssa.com v e' then
e'
else
e
| TEnumParameter(e1,ef,i) ->
let ev = value ssa true e1 in
begin try
value ssa force (semi_awkward_enum_value ssa ev i)
with Not_found ->
e
end
| _ ->
e
(* TODO: the name is quite accurate *)
let awkward_get_enum_index ssa e =
let e = awkward_get_enum_index ssa.com e in
let ev = (value ssa true e) in
match ev.eexpr with
| TField(_,FEnum(_,ef)) -> TInt (Int32.of_int ef.ef_index)
| TCall({eexpr = TField(_,FEnum(_,ef))},_) -> TInt (Int32.of_int ef.ef_index)
| _ -> raise Not_found
let apply ssa e =
let rec loop e = match e.eexpr with
| TLocal v when not (Meta.has Meta.Unbound v.v_meta) ->
set_var_usage_count v (get_var_usage_count v + 1);
| _ ->
Type.iter loop e
in
loop e;
let had_function = ref false in
let rec loop e = match e.eexpr with
| TFunction _ when !had_function ->
e
| TFunction tf ->
had_function := true;
{e with eexpr = TFunction {tf with tf_expr = loop tf.tf_expr}}
| TLocal v ->
let e' = local ssa false v e in
if can_be_inlined ssa.com v e' then
e'
else
e
| TCall({eexpr = TField(_,(FStatic(_,cf) | FInstance(_,_,cf) | FAnon cf))},el) when has_analyzer_option cf.cf_meta flag_no_const_propagation ->
e
| TCall(e1,el) ->
let e1 = loop e1 in
let check e t =
if type_has_analyzer_option t flag_no_const_propagation then e
else loop e
in
let el = Codegen.UnificationCallback.check_call check el e1.etype in
{e with eexpr = TCall(e1,el)}
(* | TField(e1,fa) ->
let e1' = loop e1 in
let fa = if e1' != e1 then
begin try quick_field e1'.etype (field_name fa)
with Not_found -> fa end
else
fa
in
{e with eexpr = TField(e1',fa)} *)
| TUnop((Increment | Decrement),_,_) ->
e
| TBinop(OpAssignOp op,e1,e2) ->
let e2 = loop e2 in
{e with eexpr = TBinop(OpAssignOp op,e1,e2)}
| TBinop(OpAssign,({eexpr = TLocal _} as e1),e2) ->
let e2 = loop e2 in
{e with eexpr = TBinop(OpAssign,e1,e2)}
| TBinop(op,e1,e2) ->
let e1 = loop e1 in
let e2 = loop e2 in
let e = {e with eexpr = TBinop(op,e1,e2)} in
let e' = Optimizer.optimize_binop e op e1 e2 in
e'
| TUnop(op,flag,e1) ->
let e1 = loop e1 in
let e = {e with eexpr = TUnop(op,flag,e1)} in
let e' = Optimizer.optimize_unop e op flag e1 in
e'
| TIf(e1,e2,eo) ->
let e1 = loop e1 in
let e2 = loop e2 in
let rec check_const e1 = match e1.eexpr with
| TConst (TBool true) ->
e2
| TConst (TBool false) ->
begin match eo with
| None ->
mk (TConst TNull) t_dynamic e.epos
| Some e ->
loop e
end
| TParenthesis e1 ->
check_const e1
| _ ->
let eo = match eo with None -> None | Some e -> Some (loop e) in
{e with eexpr = TIf(e1,e2,eo)}
in
check_const e1
| TSwitch(e1,cases,edef) ->
let e1 = loop e1 in
let rec check_constant e = match e.eexpr with
| TConst ct -> ct
| TParenthesis e1 | TCast(e1,None) | TMeta(_,e1) -> check_constant e1
| _ -> awkward_get_enum_index ssa e
in
begin try
let ct = check_constant e1 in
begin try
let _,e = List.find (fun (el,_) ->
List.exists (fun e -> match e.eexpr with
| TConst ct2 -> ct = ct2
| _ -> false
) el
) cases in
loop e
with Not_found ->
begin match edef with None -> raise Not_found | Some e -> loop e end
end
with Not_found ->
let cases = List.map (fun (el,e) -> el,loop e) cases in
let edef = match edef with None -> None | Some e -> Some (loop e) in
{e with eexpr = TSwitch(e1,cases,edef)}
end
| _ ->
Type.map_expr loop e
in
loop e
end
module EffectChecker = struct
let run com is_var_expression e =
let has_effect e = match e.eexpr with
| TVar _ -> true
| _ -> Optimizer.has_side_effect e
in
let e = if is_var_expression then
(* var initialization expressions are like assignments, so let's cheat a bit here *)
snd (Simplifier.apply com (Codegen.binop OpAssign (mk (TConst TNull) t_dynamic e.epos) e e.etype e.epos))
else e
in
let rec loop e = match e.eexpr with
| TBlock el ->
List.iter (fun e ->
if not (has_effect e) then com.warning "This expression has no effect" e.epos
) el
| _ ->
Type.iter loop e
in
loop e
end
module Checker = struct
open Ssa
let apply ssa e =
let given_warnings = ref PMap.empty in
let add_pos p =
given_warnings := PMap.add p true !given_warnings
in
let resolve_value v =
let e' = Ssa.get_var_value v in
begin match e'.eexpr with
| TLocal v' when v == v' -> e'
| _ -> e'
end
in
let rec is_null_expr e = match e.eexpr with
| TConst TNull ->
true
| TLocal v ->
(try is_null_expr (resolve_value v) with Not_found -> false)
| _ ->
false
in
let can_be_null v =
not (has_meta Meta.NotNull v.v_meta)
&& try not (List.exists (fun cond -> match cond with
| NotEqual(v',e) when v == v' && is_null_expr e -> true
| _ -> false
) (IntMap.find v.v_id ssa.var_conds)) with Not_found -> true
in
let return b p =
if b then add_pos p;
b
in
let rec can_be_null_expr vstack e =
if PMap.mem e.epos !given_warnings then
false
else match e.eexpr with
| TConst TNull ->
add_pos e.epos;
true
| TBinop((OpAssign | OpAssignOp _),_,e1) ->
can_be_null_expr vstack e1
| TBinop _ | TUnop _ ->
false
| TConst _ | TTypeExpr _ | TNew _ | TObjectDecl _ | TArrayDecl _ | TEnumParameter _ | TFunction _ | TVar _ ->
false
| TFor _ | TWhile _ | TIf _ | TSwitch _ | TTry _ | TReturn _ | TBreak | TContinue | TThrow _ ->
assert false
| TField _ | TBlock _ | TArray _ ->
false (* TODO *)
| TCall ({eexpr = TLocal {v_name = "__ssa_phi__"}},el) ->
List.exists (can_be_null_expr vstack) el
| TLocal v ->
if List.mem v.v_id vstack then
false (* not really, but let's not be a nuisance *)
else
return (can_be_null v && (try can_be_null_expr (v.v_id :: vstack) (resolve_value v) with Not_found -> true)) e.epos;
| TMeta(_,e1) | TParenthesis e1 | TCast(e1,_) ->
can_be_null_expr vstack e1
| TCall(e1,_) ->
begin match follow e1.etype with
| TFun(_,r) -> return (is_explicit_null r) e1.epos
| _ -> false
end
in
let check_null e p =
if can_be_null_expr [] e then begin
ssa.com.warning "Possible null exception" p;
end
in
let rec loop e = match e.eexpr with
| TField(e1,fa) ->
let e1 = loop e1 in
check_null e1 e.epos;
{e with eexpr = TField(e1,fa)}
| TMeta((Meta.Analyzer,[EConst(Ident "testIsNull"),_],_),e1) ->
if not (can_be_null_expr [] e) then error "Analyzer did not find a possible null exception" e.epos;
e
| TMeta((Meta.Analyzer,[EConst(Ident "testIsNotNull"),_],_),e1) ->
if (can_be_null_expr [] e) then error "Analyzer found a possible null exception" e.epos;
e
| _ ->
Type.map_expr loop e
in
loop e;
end
let rec lrev_iter f el = match el with
| e :: el ->
lrev_iter f el;
f e
| [] ->
()
let rev_iter f e = match e.eexpr with
| TConst _
| TLocal _
| TBreak
| TContinue
| TTypeExpr _ ->
()
| TArray (e1,e2)
| TBinop (_,e1,e2)
| TFor (_,e1,e2)
| TWhile (e1,e2,_) ->
f e2;
f e1;
| TThrow e
| TField (e,_)
| TEnumParameter (e,_,_)
| TParenthesis e
| TCast (e,_)
| TUnop (_,_,e)
| TMeta(_,e) ->
f e
| TArrayDecl el
| TNew (_,_,el)
| TBlock el ->
lrev_iter f el
| TObjectDecl fl ->
lrev_iter (fun (_,e) -> f e) fl
| TCall (e,el) ->
f e;
lrev_iter f el
| TVar (v,eo) ->
(match eo with None -> () | Some e -> f e)
| TFunction fu ->
f fu.tf_expr
| TIf (e,e1,e2) ->
(match e2 with None -> () | Some e -> f e);
f e1;
f e;
| TSwitch (e,cases,def) ->
(match def with None -> () | Some e -> f e);
lrev_iter (fun (el,e2) -> lrev_iter f el; f e2) cases;
f e;
| TTry (e,catches) ->
lrev_iter (fun (_,e) -> f e) catches;
f e;
| TReturn eo ->
(match eo with None -> () | Some e -> f e)
module LocalDce = struct
let apply e =
let is_used v = Meta.has Meta.Used v.v_meta || type_has_analyzer_option v.v_type flag_no_local_dce || v.v_capture in
let is_ref_type t = match t with
| TType({t_path = ["cs"],("Ref" | "Out")},_) -> true
| _ -> false
in
let rec use v =
if not (Meta.has Meta.Used v.v_meta) then begin
v.v_meta <- (Meta.Used,[],Ast.null_pos) :: v.v_meta;
try use (Ssa.get_origin_var v) with Not_found -> ()
end
in
let rec has_side_effect e =
let rec loop e =
match e.eexpr with
| TLocal v when Meta.has Meta.CompilerGenerated v.v_meta -> (try loop (Ssa.get_var_value v) with Not_found -> ())
| TBinop((OpAssign | OpAssignOp _),{eexpr = TLocal v},e2) when is_used v || has_side_effect e2 || is_ref_type v.v_type -> raise Exit
| TVar(v,None) when is_used v -> raise Exit
| TVar(v,Some e1) when is_used v || has_side_effect e1 -> raise Exit
| TConst _ | TLocal _ | TTypeExpr _ | TFunction _ -> ()
| TCall ({ eexpr = TField(_,FStatic({ cl_path = ([],"Std") },{ cf_name = "string" })) },args) -> Type.iter loop e
| TCall (({eexpr = TLocal {v_name = "__ssa_phi__"}}),el) -> ()
| TCall ({eexpr = TField(_,FEnum _)},_) -> Type.iter loop e
| TNew _ | TCall _ | TBinop ((OpAssignOp _ | OpAssign),_,_) | TUnop ((Increment|Decrement),_,_) -> raise Exit
| TReturn _ | TBreak | TContinue | TThrow _ | TCast (_,Some _) -> raise Exit
| TFor _ -> raise Exit
| TArray _ | TEnumParameter _ | TCast (_,None) | TBinop _ | TUnop _ | TParenthesis _ | TMeta _ | TWhile _
| TField _ | TIf _ | TTry _ | TSwitch _ | TArrayDecl _ | TBlock _ | TObjectDecl _ | TVar _ -> Type.iter loop e
in
try
loop e;
false
with Exit ->
true
in
let rec collect e = match e.eexpr with
| TLocal v ->
use v
| TVar(v,_) when not (is_used v) ->
(* TODO: this is probably dangerous *)
()
| _ ->
rev_iter collect e
in
let rec loop need_val e =
match e.eexpr with
| TLocal v ->
use v;
e
| TBinop(OpAssign,({eexpr = TLocal v} as e1),e2) ->
let e2 = loop false e2 in
if not (is_used v) && not (is_ref_type v.v_type) then
e2
else
{e with eexpr = TBinop(OpAssign,{e1 with eexpr = TLocal v},e2)}
| TVar(v,Some e1) when not (is_used v) ->
let e1 = if has_side_effect e1 then loop true e1 else e1 in
e1
| TWhile(e1,e2,flag) ->
collect e2;
let e2 = loop false e2 in
let e1 = loop false e1 in
{e with eexpr = TWhile(e1,e2,flag)}
| TFor(v,e1,e2) ->
collect e2;
let e2 = loop false e2 in
let e1 = loop false e1 in
{e with eexpr = TFor(v,e1,e2)}
| TBlock el ->
let rec block el = match el with
| e :: el ->
let el = block el in
if not need_val && not (has_side_effect e) then
el
else begin
let e = loop false e in
e :: el
end
| [] ->
[]
in
{e with eexpr = TBlock (block el)}
| TCall(e1, el) ->
let el = List.rev_map (loop true) (List.rev el) in
let e1 = loop false e1 in
{e with eexpr = TCall(e1,el)}
| TIf(e1,e2,e3) ->
let e3 = match e3 with None -> None | Some e -> Some (loop need_val e) in
let e2 = loop need_val e2 in
let e1 = loop false e1 in
{e with eexpr = TIf(e1,e2,e3)}
| TArrayDecl el ->
let el = List.rev_map (loop true) (List.rev el) in
{e with eexpr = TArrayDecl el}
| TObjectDecl fl ->
let fl = List.rev_map (fun (s,e) -> s,loop true e) (List.rev fl) in
{e with eexpr = TObjectDecl fl}
| _ ->
Type.map_expr (loop false) e
in
loop false e
end
module Config = struct
type analyzer_config = {
analyzer_use : bool;
simplifier_apply : bool;
ssa_apply : bool;
const_propagation : bool;
check : bool;
check_has_effect : bool;
local_dce : bool;
ssa_unapply : bool;
simplifier_unapply : bool;
}
let get_base_config com =
{
analyzer_use = true;
simplifier_apply = true;
ssa_apply = true;
const_propagation = not (Common.raw_defined com "analyzer-no-const-propagation");
check_has_effect = (Common.raw_defined com "analyzer-check-has-effect");
check = not (Common.raw_defined com "analyzer-no-check");
local_dce = not (Common.raw_defined com "analyzer-no-local-dce") && not (Common.defined com Define.As3);
ssa_unapply = not (Common.raw_defined com "analyzer-no-ssa-unapply");
simplifier_unapply = not (Common.raw_defined com "analyzer-no-simplify-unapply");
}
let update_config_from_meta config meta =
List.fold_left (fun config meta -> match meta with
| (Meta.Analyzer,el,_) ->
List.fold_left (fun config e -> match fst e with
| EConst (Ident s) when s = flag_no_check -> { config with check = false}
| EConst (Ident s) when s = flag_check -> { config with check = true}
| EConst (Ident s) when s = flag_no_const_propagation -> { config with const_propagation = false}
| EConst (Ident s) when s = flag_const_propagation -> { config with const_propagation = true}
| EConst (Ident s) when s = flag_no_local_dce -> { config with local_dce = false}
| EConst (Ident s) when s = flag_local_dce -> { config with local_dce = true}
| EConst (Ident s) when s = flag_no_check_has_effect -> { config with check_has_effect = false}
| EConst (Ident s) when s = flag_check_has_effect -> { config with check_has_effect = true}
| _ -> config
) config el
| _ ->
config
) config meta
let get_class_config com c =
let config = get_base_config com in
update_config_from_meta config c.cl_meta
let get_field_config com c cf =
let config = get_class_config com c in
update_config_from_meta config cf.cf_meta
end
module Run = struct
open Config
let run_on_expr com config is_var_expression e =
let do_simplify = (not (Common.defined com Define.NoSimplify) ) && match com.platform with
| Cpp when Common.defined com Define.Cppia -> false
| Cpp | Python -> true
| _ -> false
in
let with_timer s f =
let timer = timer s in
let r = f() in
timer();
r
in
try
let has_unbound,e = if do_simplify || config.analyzer_use then
with_timer "analyzer-simplify-apply" (fun () -> Simplifier.apply com e)
else
false,e
in
let e = if config.analyzer_use && not has_unbound then begin
if config.check_has_effect then EffectChecker.run com is_var_expression e;
let e,ssa = with_timer "analyzer-ssa-apply" (fun () -> Ssa.apply com e) in
let e = if config.const_propagation then with_timer "analyzer-const-propagation" (fun () -> ConstPropagation.apply ssa e) else e in
(* let e = if config.check then with_timer "analyzer-checker" (fun () -> Checker.apply ssa e) else e in *)
let e = if config.local_dce && config.analyzer_use && not has_unbound && not is_var_expression then with_timer "analyzer-local-dce" (fun () -> LocalDce.apply e) else e in
let e = if config.ssa_unapply then with_timer "analyzer-ssa-unapply" (fun () -> Ssa.unapply com e) else e in
List.iter (fun f -> f()) ssa.Ssa.cleanup;
e
end else
e
in
let e = if not do_simplify && not (Common.raw_defined com "analyzer-no-simplify-unapply") then
with_timer "analyzer-simplify-unapply" (fun () -> Simplifier.unapply com e)
else
e
in
e
with Exit ->
e
let run_on_field ctx config cf =
match cf.cf_expr with
| Some e when not (is_ignored cf.cf_meta) && not (Codegen.is_removable_field ctx cf) ->
let config = update_config_from_meta config cf.cf_meta in
let is_var_expression = match cf.cf_kind with
| Var _ -> true
| _ -> false
in
cf.cf_expr <- Some (run_on_expr ctx.com config is_var_expression e);
| _ -> ()
let run_on_class ctx config c =
let config = update_config_from_meta config c.cl_meta in
let process_field cf = run_on_field ctx config cf in
List.iter process_field c.cl_ordered_fields;
List.iter process_field c.cl_ordered_statics;
(match c.cl_constructor with
| None -> ()
| Some f -> process_field f);
(match c.cl_init with
| None -> ()
| Some e ->
(* never optimize init expressions (too messy) *)
c.cl_init <- Some (run_on_expr ctx.com {config with analyzer_use = false} false e))
let run_on_type ctx config t =
match t with
| TClassDecl c when (is_ignored c.cl_meta) -> ()
| TClassDecl c -> run_on_class ctx config c
| TEnumDecl _ -> ()
| TTypeDecl _ -> ()
| TAbstractDecl _ -> ()
let run_on_types ctx types =
let com = ctx.com in
let config = get_base_config com in
List.iter (run_on_type ctx config) types
end
haxe_3.2.1+dfsg.orig/appveyor.yml 0000664 0001750 0001750 00000005323 12607337712 016717 0 ustar andy andy 0000000 0000000 version: "{build}"
platform:
- Win32
environment:
global:
NEKO_ROOT: C:/projects/neko
HAXELIB_ROOT: C:/projects/haxelib
CYG_ARCH: x86
CYG_ROOT: C:/cygwin
CYG_SETUP: C:/cygwin/setup-x86.exe
MINGW_ARCH: i686
WODI: wodi32
ADD_REVISION: 1
OCAMLOPT: ocamlopt.opt
matrix:
- TEST: "neko,cs,java,macro"
- TEST: "cpp"
skip_tags: true
install:
- 'git submodule update --init --recursive'
- cinst 7zip.commandline -y
# Install ocaml using wodi
- appveyor DownloadFile "http://cygwin.com/setup-%CYG_ARCH%.exe" -FileName "%CYG_ROOT%\setup.exe"
- '%CYG_ROOT%/setup.exe -g -q -R "%CYG_ROOT%" -P dos2unix -P diffutils -P cpio -P make -P patch -P mingw64-%MINGW_ARCH%-gcc-core -P mingw64-%MINGW_ARCH%-gcc-g++ > log.txt || type log.txt'
- '%CYG_ROOT%/bin/bash -lc "cygcheck -dc cygwin" > log.txt || type log.txt'
# The archive is a dropbox hosted version of https://github.com/fdopen/godi-repo/issues/7#issuecomment-98480339
- '%CYG_ROOT%/bin/bash -lc "wget -q https://dl.dropboxusercontent.com/u/2661116/wodi/%WODI%.tar.xz -O /tmp/%WODI%.tar.xz" > log.txt || type log.txt'
- '%CYG_ROOT%/bin/bash -lc "cd /tmp && rm -rf %WODI% && tar -xf %WODI%.tar.xz && bash %WODI%/install.sh" > log.txt || type log.txt'
- '%CYG_ROOT%/bin/bash -lc "godi_add godi-zip" > log.txt || type log.txt'
- 'set PATH=%PATH%;%CYG_ROOT%/opt/%WODI%/bin'
# Install neko
- cinst make -y
- 'git clone --recursive https://github.com/HaxeFoundation/neko.git %NEKO_ROOT%'
- 'cd %NEKO_ROOT%'
- set PATH=%PATH%;%NEKO_ROOT%/bin
- msbuild neko_vc10.sln /verbosity:minimal /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" > log.txt || type log.txt
- msbuild libs/libs_vc10.sln /verbosity:minimal /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" > log.txt || type log.txt
- copy /y libs\include\gc\gc.dll bin
- cd %NEKO_ROOT%/src
- neko ../boot/nekoc tools/install.neko
- neko tools/install -nolibs > log.txt || type log.txt
- neko -version
build_script:
- 'cd %APPVEYOR_BUILD_FOLDER%'
- 'set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%'
- '%CYG_ROOT%/bin/bash -lc "cd \"$OLDPWD\" && make -s -f Makefile.win"'
- '%CYG_ROOT%/bin/bash -lc "cd \"$OLDPWD\" && make -s -f Makefile.win tools"'
- '%CYG_ROOT%/bin/bash -lc "cd \"$OLDPWD\" && make -s -f Makefile.win package_bin"'
- dir %APPVEYOR_BUILD_FOLDER%\out
- cd %APPVEYOR_BUILD_FOLDER%/tests/
- mkdir "%HAXELIB_ROOT%"
- haxelib setup "%HAXELIB_ROOT%"
test_script:
- cd %APPVEYOR_BUILD_FOLDER%/tests/
- haxe -version
- haxe RunCi.hxml
- neko RunCi.n
artifacts:
- path: out/haxe_*.zip
haxe_3.2.1+dfsg.orig/ast.ml 0000664 0001750 0001750 00000041052 12607337712 015447 0 ustar andy andy 0000000 0000000 (*
* Copyright (C)2005-2013 Haxe Foundation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*)
type pos = {
pfile : string;
pmin : int;
pmax : int;
}
module IntMap = Map.Make(struct type t = int let compare a b = a - b end)
module Meta = struct
type strict_meta =
| Abi
| Abstract
| Access
| Accessor
| Allow
| Analyzer
| Annotation
| ArrayAccess
| Ast
| AutoBuild
| Bind
| Bitmap
| BridgeProperties
| Build
| BuildXml
| Callable
| Class
| ClassCode
| Commutative
| CompilerGenerated
| CoreApi
| CoreType
| CppFileCode
| CppInclude
| CppNamespaceCode
| CsNative
| Dce
| Debug
| Decl
| DefParam
| Delegate
| Depend
| Deprecated
| DirectlyUsed
| DynamicObject
| Enum
| EnumConstructorParam
| Event
| Exhaustive
| Expose
| Extern
| FakeEnum
| File
| Final
| FlatEnum
| Font
| Forward
| From
| FunctionCode
| FunctionTailCode
| Generic
| GenericBuild
| GenericInstance
| Getter
| Hack
| HasUntyped
| HaxeGeneric
| HeaderClassCode
| HeaderCode
| HeaderInclude
| HeaderNamespaceCode
| HxGen
| IfFeature
| Impl
| PythonImport
| ImplicitCast
| Include
| InitPackage
| Internal
| IsVar
| JavaCanonical
| JavaNative
| JsRequire
| Keep
| KeepInit
| KeepSub
| LibType
| Meta
| Macro
| MaybeUsed
| MergeBlock
| MultiType
| Native
| NativeChildren
| NativeGen
| NativeGeneric
| NativeProperty
| NoCompletion
| NoDebug
| NoDoc
| NoExpr
| NoImportGlobal
| NonVirtual
| NoPackageRestrict
| NoPrivateAccess
| NoStack
| NotNull
| NoUsing
| Ns
| Op
| Optional
| Overload
| PrivateAccess
| Property
| Protected
| Public
| PublicFields
| QuotedField
| ReadOnly
| RealPath
| Remove
| Require
| RequiresAssign
(* | Resolve *)
| ReplaceReflection
| Rtti
| Runtime
| RuntimeValue
| SelfCall
| Setter
| SkipCtor
| SkipReflection
| Sound
| SourceFile
| StoredTypedExpr
| Strict
| Struct
| StructAccess
| SuppressWarnings
| This
| Throws
| To
| ToString
| Transient
| ValueUsed
| Volatile
| Unbound
| UnifyMinDynamic
| Unreflective
| Unsafe
| Usage
| Used
| Value
| Void
| Last
(* do not put any custom metadata after Last *)
| Dollar of string
| Custom of string
let has m ml = List.exists (fun (m2,_,_) -> m = m2) ml
let get m ml = List.find (fun (m2,_,_) -> m = m2) ml
let to_string_ref = ref (fun _ -> assert false)
let to_string (m : strict_meta) : string = !to_string_ref m
end
type keyword =
| Function
| Class
| Var
| If
| Else
| While
| Do
| For
| Break
| Continue
| Return
| Extends
| Implements
| Import
| Switch
| Case
| Default
| Static
| Public
| Private
| Try
| Catch
| New
| This
| Throw
| Extern
| Enum
| In
| Interface
| Untyped
| Cast
| Override
| Typedef
| Dynamic
| Package
| Inline
| Using
| Null
| True
| False
| Abstract
| Macro
type binop =
| OpAdd
| OpMult
| OpDiv
| OpSub
| OpAssign
| OpEq
| OpNotEq
| OpGt
| OpGte
| OpLt
| OpLte
| OpAnd
| OpOr
| OpXor
| OpBoolAnd
| OpBoolOr
| OpShl
| OpShr
| OpUShr
| OpMod
| OpAssignOp of binop
| OpInterval
| OpArrow
type unop =
| Increment
| Decrement
| Not
| Neg
| NegBits
type constant =
| Int of string
| Float of string
| String of string
| Ident of string
| Regexp of string * string
type token =
| Eof
| Const of constant
| Kwd of keyword
| Comment of string
| CommentLine of string
| Binop of binop
| Unop of unop
| Semicolon
| Comma
| BrOpen
| BrClose
| BkOpen
| BkClose
| POpen
| PClose
| Dot
| DblDot
| Arrow
| IntInterval of string
| Sharp of string
| Question
| At
| Dollar of string
type unop_flag =
| Prefix
| Postfix
type while_flag =
| NormalWhile
| DoWhile
type type_path = {
tpackage : string list;
tname : string;
tparams : type_param_or_const list;
tsub : string option;
}
and type_param_or_const =
| TPType of complex_type
| TPExpr of expr
and complex_type =
| CTPath of type_path
| CTFunction of complex_type list * complex_type
| CTAnonymous of class_field list
| CTParent of complex_type
| CTExtend of type_path list * class_field list
| CTOptional of complex_type
and func = {
f_params : type_param list;
f_args : (string * bool * complex_type option * expr option) list;
f_type : complex_type option;
f_expr : expr option;
}
and expr_def =
| EConst of constant
| EArray of expr * expr
| EBinop of binop * expr * expr
| EField of expr * string
| EParenthesis of expr
| EObjectDecl of (string * expr) list
| EArrayDecl of expr list
| ECall of expr * expr list
| ENew of type_path * expr list
| EUnop of unop * unop_flag * expr
| EVars of (string * complex_type option * expr option) list
| EFunction of string option * func
| EBlock of expr list
| EFor of expr * expr
| EIn of expr * expr
| EIf of expr * expr * expr option
| EWhile of expr * expr * while_flag
| ESwitch of expr * (expr list * expr option * expr option) list * expr option option
| ETry of expr * (string * complex_type * expr) list
| EReturn of expr option
| EBreak
| EContinue
| EUntyped of expr
| EThrow of expr
| ECast of expr * complex_type option
| EDisplay of expr * bool
| EDisplayNew of type_path
| ETernary of expr * expr * expr
| ECheckType of expr * complex_type
| EMeta of metadata_entry * expr
and expr = expr_def * pos
and type_param = {
tp_name : string;
tp_params : type_param list;
tp_constraints : complex_type list;
}
and documentation = string option
and metadata_entry = (Meta.strict_meta * expr list * pos)
and metadata = metadata_entry list
and access =
| APublic
| APrivate
| AStatic
| AOverride
| ADynamic
| AInline
| AMacro
and class_field_kind =
| FVar of complex_type option * expr option
| FFun of func
| FProp of string * string * complex_type option * expr option
and class_field = {
cff_name : string;
cff_doc : documentation;
cff_pos : pos;
mutable cff_meta : metadata;
mutable cff_access : access list;
mutable cff_kind : class_field_kind;
}
type enum_flag =
| EPrivate
| EExtern
type class_flag =
| HInterface
| HExtern
| HPrivate
| HExtends of type_path
| HImplements of type_path
type abstract_flag =
| APrivAbstract
| AFromType of complex_type
| AToType of complex_type
| AIsType of complex_type
type enum_constructor = {
ec_name : string;
ec_doc : documentation;
ec_meta : metadata;
ec_args : (string * bool * complex_type) list;
ec_pos : pos;
ec_params : type_param list;
ec_type : complex_type option;
}
type ('a,'b) definition = {
d_name : string;
d_doc : documentation;
d_params : type_param list;
d_meta : metadata;
d_flags : 'a list;
d_data : 'b;
}
type import_mode =
| INormal
| IAsName of string
| IAll
type type_def =
| EClass of (class_flag, class_field list) definition
| EEnum of (enum_flag, enum_constructor list) definition
| ETypedef of (enum_flag, complex_type) definition
| EAbstract of (abstract_flag, class_field list) definition
| EImport of (string * pos) list * import_mode
| EUsing of type_path
type type_decl = type_def * pos
type package = string list * type_decl list
exception Error of string * pos
let is_lower_ident i =
let rec loop p =
match String.unsafe_get i p with
| 'a'..'z' -> true
| '_' -> if p + 1 < String.length i then loop (p + 1) else true
| _ -> false
in
loop 0
let pos = snd
let rec is_postfix (e,_) op = match op with
| Increment | Decrement -> true
| Not | Neg | NegBits -> false
let is_prefix = function
| Increment | Decrement -> true
| Not | Neg | NegBits -> true
let base_class_name = snd
let null_pos = { pfile = "?"; pmin = -1; pmax = -1 }
let punion p p2 =
{
pfile = p.pfile;
pmin = min p.pmin p2.pmin;
pmax = max p.pmax p2.pmax;
}
let rec punion_el el = match el with
| [] ->
null_pos
| (_,p) :: [] ->
p
| (_,p) :: el ->
punion p (punion_el el)
let s_type_path (p,s) = match p with [] -> s | _ -> String.concat "." p ^ "." ^ s
let parse_path s =
match List.rev (ExtString.String.nsplit s ".") with
| [] -> failwith "Invalid empty path"
| x :: l -> List.rev l, x
let s_escape ?(hex=true) s =
let b = Buffer.create (String.length s) in
for i = 0 to (String.length s) - 1 do
match s.[i] with
| '\n' -> Buffer.add_string b "\\n"
| '\t' -> Buffer.add_string b "\\t"
| '\r' -> Buffer.add_string b "\\r"
| '"' -> Buffer.add_string b "\\\""
| '\\' -> Buffer.add_string b "\\\\"
| c when int_of_char c < 32 && hex -> Buffer.add_string b (Printf.sprintf "\\x%.2X" (int_of_char c))
| c -> Buffer.add_char b c
done;
Buffer.contents b
let s_constant = function
| Int s -> s
| Float s -> s
| String s -> "\"" ^ s_escape s ^ "\""
| Ident s -> s
| Regexp (r,o) -> "~/" ^ r ^ "/"
let s_access = function
| APublic -> "public"
| APrivate -> "private"
| AStatic -> "static"
| AOverride -> "override"
| ADynamic -> "dynamic"
| AInline -> "inline"
| AMacro -> "macro"
let s_keyword = function
| Function -> "function"
| Class -> "class"
| Static -> "static"
| Var -> "var"
| If -> "if"
| Else -> "else"
| While -> "while"
| Do -> "do"
| For -> "for"
| Break -> "break"
| Return -> "return"
| Continue -> "continue"
| Extends -> "extends"
| Implements -> "implements"
| Import -> "import"
| Switch -> "switch"
| Case -> "case"
| Default -> "default"
| Private -> "private"
| Public -> "public"
| Try -> "try"
| Catch -> "catch"
| New -> "new"
| This -> "this"
| Throw -> "throw"
| Extern -> "extern"
| Enum -> "enum"
| In -> "in"
| Interface -> "interface"
| Untyped -> "untyped"
| Cast -> "cast"
| Override -> "override"
| Typedef -> "typedef"
| Dynamic -> "dynamic"
| Package -> "package"
| Inline -> "inline"
| Using -> "using"
| Null -> "null"
| True -> "true"
| False -> "false"
| Abstract -> "abstract"
| Macro -> "macro"
let rec s_binop = function
| OpAdd -> "+"
| OpMult -> "*"
| OpDiv -> "/"
| OpSub -> "-"
| OpAssign -> "="
| OpEq -> "=="
| OpNotEq -> "!="
| OpGte -> ">="
| OpLte -> "<="
| OpGt -> ">"
| OpLt -> "<"
| OpAnd -> "&"
| OpOr -> "|"
| OpXor -> "^"
| OpBoolAnd -> "&&"
| OpBoolOr -> "||"
| OpShr -> ">>"
| OpUShr -> ">>>"
| OpShl -> "<<"
| OpMod -> "%"
| OpAssignOp op -> s_binop op ^ "="
| OpInterval -> "..."
| OpArrow -> "=>"
let s_unop = function
| Increment -> "++"
| Decrement -> "--"
| Not -> "!"
| Neg -> "-"
| NegBits -> "~"
let s_token = function
| Eof -> ""
| Const c -> s_constant c
| Kwd k -> s_keyword k
| Comment s -> "/*"^s^"*/"
| CommentLine s -> "//"^s
| Binop o -> s_binop o
| Unop o -> s_unop o
| Semicolon -> ";"
| Comma -> ","
| BkOpen -> "["
| BkClose -> "]"
| BrOpen -> "{"
| BrClose -> "}"
| POpen -> "("
| PClose -> ")"
| Dot -> "."
| DblDot -> ":"
| Arrow -> "->"
| IntInterval s -> s ^ "..."
| Sharp s -> "#" ^ s
| Question -> "?"
| At -> "@"
| Dollar v -> "$" ^ v
let unescape s =
let b = Buffer.create 0 in
let rec loop esc i =
if i = String.length s then
()
else
let c = s.[i] in
if esc then begin
let inext = ref (i + 1) in
(match c with
| 'n' -> Buffer.add_char b '\n'
| 'r' -> Buffer.add_char b '\r'
| 't' -> Buffer.add_char b '\t'
| '"' | '\'' | '\\' -> Buffer.add_char b c
| '0'..'3' ->
let c = (try char_of_int (int_of_string ("0o" ^ String.sub s i 3)) with _ -> raise Exit) in
Buffer.add_char b c;
inext := !inext + 2;
| 'x' ->
let c = (try char_of_int (int_of_string ("0x" ^ String.sub s (i+1) 2)) with _ -> raise Exit) in
Buffer.add_char b c;
inext := !inext + 2;
| 'u' ->
let (u, a) =
try
(int_of_string ("0x" ^ String.sub s (i+1) 4), 4)
with _ -> try
assert (s.[i+1] = '{');
let l = String.index_from s (i+3) '}' - (i+2) in
let u = int_of_string ("0x" ^ String.sub s (i+2) l) in
assert (u <= 0x10FFFF);
(u, l+2)
with _ ->
raise Exit
in
let ub = UTF8.Buf.create 0 in
UTF8.Buf.add_char ub (UChar.uchar_of_int u);
Buffer.add_string b (UTF8.Buf.contents ub);
inext := !inext + a;
| _ ->
raise Exit);
loop false !inext;
end else
match c with
| '\\' -> loop true (i + 1)
| c ->
Buffer.add_char b c;
loop false (i + 1)
in
loop false 0;
Buffer.contents b
let map_expr loop (e,p) =
let opt f o =
match o with None -> None | Some v -> Some (f v)
in
let rec tparam = function
| TPType t -> TPType (ctype t)
| TPExpr e -> TPExpr (loop e)
and cfield f =
{ f with cff_kind = (match f.cff_kind with
| FVar (t,e) -> FVar (opt ctype t, opt loop e)
| FFun f -> FFun (func f)
| FProp (get,set,t,e) -> FProp (get,set,opt ctype t,opt loop e))
}
and ctype = function
| CTPath t -> CTPath (tpath t)
| CTFunction (cl,c) -> CTFunction (List.map ctype cl, ctype c)
| CTAnonymous fl -> CTAnonymous (List.map cfield fl)
| CTParent t -> CTParent (ctype t)
| CTExtend (tl,fl) -> CTExtend (List.map tpath tl, List.map cfield fl)
| CTOptional t -> CTOptional (ctype t)
and tparamdecl t =
{ tp_name = t.tp_name; tp_constraints = List.map ctype t.tp_constraints; tp_params = List.map tparamdecl t.tp_params }
and func f =
{
f_params = List.map tparamdecl f.f_params;
f_args = List.map (fun (n,o,t,e) -> n,o,opt ctype t,opt loop e) f.f_args;
f_type = opt ctype f.f_type;
f_expr = opt loop f.f_expr;
}
and tpath t = { t with tparams = List.map tparam t.tparams }
in
let e = (match e with
| EConst _ -> e
| EArray (e1,e2) -> EArray (loop e1, loop e2)
| EBinop (op,e1,e2) -> EBinop (op,loop e1, loop e2)
| EField (e,f) -> EField (loop e, f)
| EParenthesis e -> EParenthesis (loop e)
| EObjectDecl fl -> EObjectDecl (List.map (fun (f,e) -> f,loop e) fl)
| EArrayDecl el -> EArrayDecl (List.map loop el)
| ECall (e,el) -> ECall (loop e, List.map loop el)
| ENew (t,el) -> ENew (tpath t,List.map loop el)
| EUnop (op,f,e) -> EUnop (op,f,loop e)
| EVars vl -> EVars (List.map (fun (n,t,eo) -> n,opt ctype t,opt loop eo) vl)
| EFunction (n,f) -> EFunction (n,func f)
| EBlock el -> EBlock (List.map loop el)
| EFor (e1,e2) -> EFor (loop e1, loop e2)
| EIn (e1,e2) -> EIn (loop e1, loop e2)
| EIf (e,e1,e2) -> EIf (loop e, loop e1, opt loop e2)
| EWhile (econd,e,f) -> EWhile (loop econd, loop e, f)
| ESwitch (e,cases,def) -> ESwitch (loop e, List.map (fun (el,eg,e) -> List.map loop el, opt loop eg, opt loop e) cases, opt (opt loop) def)
| ETry (e, catches) -> ETry (loop e, List.map (fun (n,t,e) -> n,ctype t,loop e) catches)
| EReturn e -> EReturn (opt loop e)
| EBreak -> EBreak
| EContinue -> EContinue
| EUntyped e -> EUntyped (loop e)
| EThrow e -> EThrow (loop e)
| ECast (e,t) -> ECast (loop e,opt ctype t)
| EDisplay (e,f) -> EDisplay (loop e,f)
| EDisplayNew t -> EDisplayNew (tpath t)
| ETernary (e1,e2,e3) -> ETernary (loop e1,loop e2,loop e3)
| ECheckType (e,t) -> ECheckType (loop e, ctype t)
| EMeta (m,e) -> EMeta(m, loop e)
) in
(e,p)
let rec s_expr (e,_) =
match e with
| EConst c -> s_constant c
| EParenthesis e -> "(" ^ (s_expr e) ^ ")"
| EArrayDecl el -> "[" ^ (String.concat "," (List.map s_expr el)) ^ "]"
| EObjectDecl fl -> "{" ^ (String.concat "," (List.map (fun (n,e) -> n ^ ":" ^ (s_expr e)) fl)) ^ "}"
| EBinop (op,e1,e2) -> s_expr e1 ^ s_binop op ^ s_expr e2
| ECall (e,el) -> s_expr e ^ "(" ^ (String.concat ", " (List.map s_expr el)) ^ ")"
| EField (e,f) -> s_expr e ^ "." ^ f
| _ -> "'???'"
let get_value_meta meta =
try
begin match Meta.get Meta.Value meta with
| (_,[EObjectDecl values,_],_) -> List.fold_left (fun acc (s,e) -> PMap.add s e acc) PMap.empty values
| _ -> raise Not_found
end
with Not_found ->
PMap.empty
let rec string_list_of_expr_path_raise (e,p) =
match e with
| EConst (Ident i) -> [i]
| EField (e,f) -> f :: string_list_of_expr_path_raise e
| _ -> raise Exit
haxe_3.2.1+dfsg.orig/codegen.ml 0000664 0001750 0001750 00000202262 12607337712 016266 0 ustar andy andy 0000000 0000000 (*
* Copyright (C)2005-2013 Haxe Foundation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*)
open Ast
open Type
open Common
open Typecore
(* -------------------------------------------------------------------------- *)
(* TOOLS *)
let field e name t p =
mk (TField (e,try quick_field e.etype name with Not_found -> assert false)) t p
let fcall e name el ret p =
let ft = tfun (List.map (fun e -> e.etype) el) ret in
mk (TCall (field e name ft p,el)) ret p
let mk_parent e =
mk (TParenthesis e) e.etype e.epos
let string com str p =
mk (TConst (TString str)) com.basic.tstring p
let binop op a b t p =
mk (TBinop (op,a,b)) t p
let index com e index t p =
mk (TArray (e,mk (TConst (TInt (Int32.of_int index))) com.basic.tint p)) t p
let maybe_cast e t =
try
type_eq EqDoNotFollowNull e.etype t;
e
with
Unify_error _ -> mk (TCast(e,None)) t e.epos
let type_constant com c p =
let t = com.basic in
match c with
| Int s ->
if String.length s > 10 && String.sub s 0 2 = "0x" then error "Invalid hexadecimal integer" p;
(try mk (TConst (TInt (Int32.of_string s))) t.tint p
with _ -> mk (TConst (TFloat s)) t.tfloat p)
| Float f -> mk (TConst (TFloat f)) t.tfloat p
| String s -> mk (TConst (TString s)) t.tstring p
| Ident "true" -> mk (TConst (TBool true)) t.tbool p
| Ident "false" -> mk (TConst (TBool false)) t.tbool p
| Ident "null" -> mk (TConst TNull) (t.tnull (mk_mono())) p
| Ident t -> error ("Invalid constant : " ^ t) p
| Regexp _ -> error "Invalid constant" p
let rec type_constant_value com (e,p) =
match e with
| EConst c ->
type_constant com c p
| EParenthesis e ->
type_constant_value com e
| EObjectDecl el ->
mk (TObjectDecl (List.map (fun (n,e) -> n, type_constant_value com e) el)) (TAnon { a_fields = PMap.empty; a_status = ref Closed }) p
| EArrayDecl el ->
mk (TArrayDecl (List.map (type_constant_value com) el)) (com.basic.tarray t_dynamic) p
| _ ->
error "Constant value expected" p
let rec has_properties c =
List.exists (fun f ->
match f.cf_kind with
| Var { v_read = AccCall } -> true
| Var { v_write = AccCall } -> true
| _ when Meta.has Meta.Accessor f.cf_meta -> true
| _ -> false
) c.cl_ordered_fields || (match c.cl_super with Some (c,_) -> has_properties c | _ -> false)
let get_properties fields =
List.fold_left (fun acc f ->
if Meta.has Meta.Accessor f.cf_meta then
(f.cf_name, f.cf_name) :: acc
else
let acc = (match f.cf_kind with
| Var { v_read = AccCall } -> ("get_" ^ f.cf_name , "get_" ^ f.cf_name) :: acc
| _ -> acc) in
match f.cf_kind with
| Var { v_write = AccCall } -> ("set_" ^ f.cf_name , "set_" ^ f.cf_name) :: acc
| _ -> acc
) [] fields
let add_property_field com c =
let p = c.cl_pos in
let props = get_properties (c.cl_ordered_statics @ c.cl_ordered_fields) in
match props with
| [] -> ()
| _ ->
let fields,values = List.fold_left (fun (fields,values) (n,v) ->
let cf = mk_field n com.basic.tstring p in
PMap.add n cf fields,(n, string com v p) :: values
) (PMap.empty,[]) props in
let t = mk_anon fields in
let e = mk (TObjectDecl values) t p in
let cf = mk_field "__properties__" t p in
cf.cf_expr <- Some e;
c.cl_statics <- PMap.add cf.cf_name cf c.cl_statics;
c.cl_ordered_statics <- cf :: c.cl_ordered_statics
let is_removable_field ctx f =
Meta.has Meta.Extern f.cf_meta || Meta.has Meta.Generic f.cf_meta
|| (match f.cf_kind with
| Var {v_read = AccRequire (s,_)} -> true
| Method MethMacro -> not ctx.in_macro
| _ -> false)
let escape_res_name name allow_dirs =
ExtString.String.replace_chars (fun chr ->
if (chr >= 'a' && chr <= 'z') || (chr >= 'A' && chr <= 'Z') || (chr >= '0' && chr <= '9') || chr = '_' || chr = '.' then
Char.escaped chr
else if chr = '/' && allow_dirs then
"/"
else
"-x" ^ (string_of_int (Char.code chr))) name
(* -------------------------------------------------------------------------- *)
(* REMOTING PROXYS *)
let extend_remoting ctx c t p async prot =
if c.cl_super <> None then error "Cannot extend several classes" p;
(* remove forbidden packages *)
let rules = ctx.com.package_rules in
ctx.com.package_rules <- PMap.foldi (fun key r acc -> match r with Forbidden -> acc | _ -> PMap.add key r acc) rules PMap.empty;
(* parse module *)
let path = (t.tpackage,t.tname) in
let new_name = (if async then "Async_" else "Remoting_") ^ t.tname in
(* check if the proxy already exists *)
let t = (try
Typeload.load_type_def ctx p { tpackage = fst path; tname = new_name; tparams = []; tsub = None }
with
Error (Module_not_found _,p2) when p == p2 ->
(* build it *)
Common.log ctx.com ("Building proxy for " ^ s_type_path path);
let file, decls = (try
Typeload.parse_module ctx path p
with
| Not_found -> ctx.com.package_rules <- rules; error ("Could not load proxy module " ^ s_type_path path ^ (if fst path = [] then " (try using absolute path)" else "")) p
| e -> ctx.com.package_rules <- rules; raise e) in
ctx.com.package_rules <- rules;
let base_fields = [
{ cff_name = "__cnx"; cff_pos = p; cff_doc = None; cff_meta = []; cff_access = []; cff_kind = FVar (Some (CTPath { tpackage = ["haxe";"remoting"]; tname = if async then "AsyncConnection" else "Connection"; tparams = []; tsub = None }),None) };
{ cff_name = "new"; cff_pos = p; cff_doc = None; cff_meta = []; cff_access = [APublic]; cff_kind = FFun { f_args = ["c",false,None,None]; f_type = None; f_expr = Some (EBinop (OpAssign,(EConst (Ident "__cnx"),p),(EConst (Ident "c"),p)),p); f_params = [] } };
] in
let tvoid = CTPath { tpackage = []; tname = "Void"; tparams = []; tsub = None } in
let build_field is_public acc f =
if f.cff_name = "new" then
acc
else match f.cff_kind with
| FFun fd when (is_public || List.mem APublic f.cff_access) && not (List.mem AStatic f.cff_access) ->
if List.exists (fun (_,_,t,_) -> t = None) fd.f_args then error ("Field " ^ f.cff_name ^ " type is not complete and cannot be used by RemotingProxy") p;
let eargs = [EArrayDecl (List.map (fun (a,_,_,_) -> (EConst (Ident a),p)) fd.f_args),p] in
let ftype = (match fd.f_type with Some (CTPath { tpackage = []; tname = "Void" }) -> None | _ -> fd.f_type) in
let fargs, eargs = if async then match ftype with
| Some tret -> fd.f_args @ ["__callb",true,Some (CTFunction ([tret],tvoid)),None], eargs @ [EConst (Ident "__callb"),p]
| _ -> fd.f_args, eargs @ [EConst (Ident "null"),p]
else
fd.f_args, eargs
in
let id = (EConst (String f.cff_name), p) in
let id = if prot then id else ECall ((EConst (Ident "__unprotect__"),p),[id]),p in
let expr = ECall (
(EField (
(ECall ((EField ((EConst (Ident "__cnx"),p),"resolve"),p),[id]),p),
"call")
,p),eargs),p
in
let expr = if async || ftype = None then expr else (EReturn (Some expr),p) in
let fd = {
f_params = fd.f_params;
f_args = fargs;
f_type = if async then None else ftype;
f_expr = Some (EBlock [expr],p);
} in
{ cff_name = f.cff_name; cff_pos = p; cff_doc = None; cff_meta = []; cff_access = [APublic]; cff_kind = FFun fd } :: acc
| _ -> acc
in
let decls = List.map (fun d ->
match d with
| EClass c, p when c.d_name = t.tname ->
let is_public = List.mem HExtern c.d_flags || List.mem HInterface c.d_flags in
let fields = List.rev (List.fold_left (build_field is_public) base_fields c.d_data) in
(EClass { c with d_flags = []; d_name = new_name; d_data = fields },p)
| _ -> d
) decls in
let m = Typeload.type_module ctx (t.tpackage,new_name) file decls p in
add_dependency ctx.m.curmod m;
try
List.find (fun tdecl -> snd (t_path tdecl) = new_name) m.m_types
with Not_found ->
error ("Module " ^ s_type_path path ^ " does not define type " ^ t.tname) p
) in
match t with
| TClassDecl c2 when c2.cl_params = [] -> ignore(c2.cl_build()); c.cl_super <- Some (c2,[]);
| _ -> error "Remoting proxy must be a class without parameters" p
(* -------------------------------------------------------------------------- *)
(* HAXE.RTTI.GENERIC *)
exception Generic_Exception of string * Ast.pos
type generic_context = {
ctx : typer;
subst : (t * t) list;
name : string;
p : pos;
mutable mg : module_def option;
}
let make_generic ctx ps pt p =
let rec loop l1 l2 =
match l1, l2 with
| [] , [] -> []
| (x,TLazy f) :: l1, _ -> loop ((x,(!f)()) :: l1) l2
| (_,t1) :: l1 , t2 :: l2 -> (t1,t2) :: loop l1 l2
| _ -> assert false
in
let name =
String.concat "_" (List.map2 (fun (s,_) t ->
let s_type_path_underscore (p,s) = match p with [] -> s | _ -> String.concat "_" p ^ "_" ^ s in
let rec loop top t = match follow t with
| TInst(c,tl) -> (s_type_path_underscore c.cl_path) ^ (loop_tl tl)
| TEnum(en,tl) -> (s_type_path_underscore en.e_path) ^ (loop_tl tl)
| TAbstract(a,tl) -> (s_type_path_underscore a.a_path) ^ (loop_tl tl)
| _ when not top -> "_" (* allow unknown/incompatible types as type parameters to retain old behavior *)
| TMono _ -> raise (Generic_Exception (("Could not determine type for parameter " ^ s), p))
| t -> raise (Generic_Exception (("Type parameter must be a class or enum instance (found " ^ (s_type (print_context()) t) ^ ")"), p))
and loop_tl tl = match tl with
| [] -> ""
| tl -> "_" ^ String.concat "_" (List.map (loop false) tl)
in
loop true t
) ps pt)
in
{
ctx = ctx;
subst = loop ps pt;
name = name;
p = p;
mg = None;
}
let rec generic_substitute_type gctx t =
match t with
| TInst ({ cl_kind = KGeneric } as c2,tl2) ->
(* maybe loop, or generate cascading generics *)
let _, _, f = gctx.ctx.g.do_build_instance gctx.ctx (TClassDecl c2) gctx.p in
let t = f (List.map (generic_substitute_type gctx) tl2) in
(match follow t,gctx.mg with TInst(c,_), Some m -> add_dependency m c.cl_module | _ -> ());
t
| _ ->
try
generic_substitute_type gctx (List.assq t gctx.subst)
with Not_found ->
Type.map (generic_substitute_type gctx) t
let generic_substitute_expr gctx e =
let vars = Hashtbl.create 0 in
let build_var v =
try
Hashtbl.find vars v.v_id
with Not_found ->
let v2 = alloc_var v.v_name (generic_substitute_type gctx v.v_type) in
v2.v_meta <- v.v_meta;
Hashtbl.add vars v.v_id v2;
v2
in
let rec build_expr e =
match e.eexpr with
| TField(e1, FInstance({cl_kind = KGeneric} as c,tl,cf)) ->
let _, _, f = gctx.ctx.g.do_build_instance gctx.ctx (TClassDecl c) gctx.p in
let t = f (List.map (generic_substitute_type gctx) tl) in
build_expr {e with eexpr = TField(e1,quick_field t cf.cf_name)}
| _ ->
map_expr_type build_expr (generic_substitute_type gctx) build_var e
in
build_expr e
let has_ctor_constraint c = match c.cl_kind with
| KTypeParameter tl ->
List.exists (fun t -> match follow t with
| TAnon a when PMap.mem "new" a.a_fields -> true
| _ -> false
) tl;
| _ -> false
let get_short_name =
let i = ref (-1) in
(fun () ->
incr i;
Printf.sprintf "Hx___short___hx_type_%i" !i
)
let rec build_generic ctx c p tl =
let pack = fst c.cl_path in
let recurse = ref false in
let rec check_recursive t =
match follow t with
| TInst (c2,tl) ->
(match c2.cl_kind with
| KTypeParameter tl ->
if not (Typeload.is_generic_parameter ctx c2) && has_ctor_constraint c2 then
error "Type parameters with a constructor cannot be used non-generically" p;
recurse := true
| _ -> ());
List.iter check_recursive tl;
| _ ->
()
in
List.iter check_recursive tl;
if !recurse then begin
TInst (c,tl) (* build a normal instance *)
end else begin
let gctx = make_generic ctx c.cl_params tl p in
let name = (snd c.cl_path) ^ "_" ^ gctx.name in
try
Typeload.load_instance ctx { tpackage = pack; tname = name; tparams = []; tsub = None } p false
with Error(Module_not_found path,_) when path = (pack,name) ->
let m = (try Hashtbl.find ctx.g.modules (Hashtbl.find ctx.g.types_module c.cl_path) with Not_found -> assert false) in
let ctx = { ctx with m = { ctx.m with module_types = m.m_types @ ctx.m.module_types } } in
ignore(c.cl_build()); (* make sure the super class is already setup *)
let mg = {
m_id = alloc_mid();
m_path = (pack,name);
m_types = [];
m_extra = module_extra (s_type_path (pack,name)) m.m_extra.m_sign 0. MFake;
} in
gctx.mg <- Some mg;
let cg = mk_class mg (pack,name) c.cl_pos in
mg.m_types <- [TClassDecl cg];
Hashtbl.add ctx.g.modules mg.m_path mg;
add_dependency mg m;
add_dependency ctx.m.curmod mg;
(* ensure that type parameters are set in dependencies *)
let dep_stack = ref [] in
let rec loop t =
if not (List.memq t !dep_stack) then begin
dep_stack := t :: !dep_stack;
match t with
| TInst (c,tl) -> add_dep c.cl_module tl
| TEnum (e,tl) -> add_dep e.e_module tl
| TType (t,tl) -> add_dep t.t_module tl
| TAbstract (a,tl) -> add_dep a.a_module tl
| TMono r ->
(match !r with
| None -> ()
| Some t -> loop t)
| TLazy f ->
loop ((!f)());
| TDynamic t2 ->
if t == t2 then () else loop t2
| TAnon a ->
PMap.iter (fun _ f -> loop f.cf_type) a.a_fields
| TFun (args,ret) ->
List.iter (fun (_,_,t) -> loop t) args;
loop ret
end
and add_dep m tl =
add_dependency mg m;
List.iter loop tl
in
List.iter loop tl;
let build_field cf_old =
let cf_new = {cf_old with cf_pos = cf_old.cf_pos} in (* copy *)
let f () =
let t = generic_substitute_type gctx cf_old.cf_type in
ignore (follow t);
begin try (match cf_old.cf_expr with
| None ->
begin match cf_old.cf_kind with
| Method _ when not c.cl_interface && not c.cl_extern ->
display_error ctx (Printf.sprintf "Field %s has no expression (possible typing order issue)" cf_new.cf_name) cf_new.cf_pos;
display_error ctx (Printf.sprintf "While building %s" (s_type_path cg.cl_path)) p;
| _ ->
()
end
| Some e ->
cf_new.cf_expr <- Some (generic_substitute_expr gctx e)
) with Unify_error l ->
error (error_msg (Unify l)) cf_new.cf_pos
end;
t
in
let r = exc_protect ctx (fun r ->
let t = mk_mono() in
r := (fun() -> t);
unify_raise ctx (f()) t p;
t
) "build_generic" in
delay ctx PForce (fun() -> ignore ((!r)()));
cf_new.cf_type <- TLazy r;
cf_new
in
if c.cl_init <> None || c.cl_dynamic <> None then error "This class can't be generic" p;
List.iter (fun cf -> match cf.cf_kind with
| Method MethMacro when not ctx.in_macro -> ()
| _ -> error "A generic class can't have static fields" cf.cf_pos
) c.cl_ordered_statics;
cg.cl_super <- (match c.cl_super with
| None -> None
| Some (cs,pl) ->
let find_class subst =
let rec loop subst = match subst with
| (TInst(c,[]),t) :: subst when c == cs -> t
| _ :: subst -> loop subst
| [] -> raise Not_found
in
try
if pl <> [] then raise Not_found;
let t = loop subst in
(* extended type parameter: concrete type must have a constructor, but generic base class must not have one *)
begin match follow t,c.cl_constructor with
| TInst(cs,_),None ->
ignore(cs.cl_build());
begin match cs.cl_constructor with
| None -> error ("Cannot use " ^ (s_type_path cs.cl_path) ^ " as type parameter because it is extended and has no constructor") p
| _ -> ()
end;
| _,Some cf -> error "Generics extending type parameters cannot have constructors" cf.cf_pos
| _ -> ()
end;
t
with Not_found ->
apply_params c.cl_params tl (TInst(cs,pl))
in
let ts = follow (find_class gctx.subst) in
let cs,pl = Typeload.check_extends ctx c ts p in
match cs.cl_kind with
| KGeneric ->
(match build_generic ctx cs p pl with
| TInst (cs,pl) -> Some (cs,pl)
| _ -> assert false)
| _ -> Some(cs,pl)
);
Typeload.add_constructor ctx cg false p;
cg.cl_kind <- KGenericInstance (c,tl);
cg.cl_meta <- (Meta.NoDoc,[],p) :: cg.cl_meta;
cg.cl_interface <- c.cl_interface;
cg.cl_constructor <- (match cg.cl_constructor, c.cl_constructor, c.cl_super with
| _, Some cf, _ -> Some (build_field cf)
| Some ctor, _, _ -> Some ctor
| None, None, None -> None
| _ -> error "Please define a constructor for this class in order to use it as generic" c.cl_pos
);
cg.cl_implements <- List.map (fun (i,tl) ->
(match follow (generic_substitute_type gctx (TInst (i, List.map (generic_substitute_type gctx) tl))) with
| TInst (i,tl) -> i, tl
| _ -> assert false)
) c.cl_implements;
cg.cl_ordered_fields <- List.map (fun f ->
let f = build_field f in
cg.cl_fields <- PMap.add f.cf_name f cg.cl_fields;
f
) c.cl_ordered_fields;
(* In rare cases the class name can become too long, so let's shorten it (issue #3090). *)
if String.length (snd cg.cl_path) > 254 then begin
let n = get_short_name () in
cg.cl_meta <- (Meta.Native,[EConst(String (n)),p],p) :: cg.cl_meta;
end;
TInst (cg,[])
end
(* -------------------------------------------------------------------------- *)
(* HAXE.XML.PROXY *)
let extend_xml_proxy ctx c t file p =
let t = Typeload.load_complex_type ctx p t in
let file = (try Common.find_file ctx.com file with Not_found -> file) in
add_dependency c.cl_module (create_fake_module ctx file);
let used = ref PMap.empty in
let print_results() =
PMap.iter (fun id used ->
if not used then ctx.com.warning (id ^ " is not used") p;
) (!used)
in
let check_used = Common.defined ctx.com Define.CheckXmlProxy in
if check_used then ctx.g.hook_generate <- print_results :: ctx.g.hook_generate;
try
let rec loop = function
| Xml.Element (_,attrs,childs) ->
(try
let id = List.assoc "id" attrs in
if PMap.mem id c.cl_fields then error ("Duplicate id " ^ id) p;
let t = if not check_used then t else begin
used := PMap.add id false (!used);
let ft() = used := PMap.add id true (!used); t in
TLazy (ref ft)
end in
let f = {
cf_name = id;
cf_type = t;
cf_public = true;
cf_pos = p;
cf_doc = None;
cf_meta = no_meta;
cf_kind = Var { v_read = AccResolve; v_write = AccNo };
cf_params = [];
cf_expr = None;
cf_overloads = [];
} in
c.cl_fields <- PMap.add id f c.cl_fields;
with
Not_found -> ());
List.iter loop childs;
| Xml.PCData _ -> ()
in
loop (Xml.parse_file file)
with
| Xml.Error e -> error ("XML error " ^ Xml.error e) p
| Xml.File_not_found f -> error ("XML File not found : " ^ f) p
(* -------------------------------------------------------------------------- *)
(* BUILD META DATA OBJECT *)
let build_metadata com t =
let api = com.basic in
let p, meta, fields, statics = (match t with
| TClassDecl c ->
let fields = List.map (fun f -> f.cf_name,f.cf_meta) (c.cl_ordered_fields @ (match c.cl_constructor with None -> [] | Some f -> [{ f with cf_name = "_" }])) in
let statics = List.map (fun f -> f.cf_name,f.cf_meta) c.cl_ordered_statics in
(c.cl_pos, ["",c.cl_meta],fields,statics)
| TEnumDecl e ->
(e.e_pos, ["",e.e_meta],List.map (fun n -> n, (PMap.find n e.e_constrs).ef_meta) e.e_names, [])
| TTypeDecl t ->
(t.t_pos, ["",t.t_meta],(match follow t.t_type with TAnon a -> PMap.fold (fun f acc -> (f.cf_name,f.cf_meta) :: acc) a.a_fields [] | _ -> []),[])
| TAbstractDecl a ->
(a.a_pos, ["",a.a_meta],[],[])
) in
let filter l =
let l = List.map (fun (n,ml) -> n, ExtList.List.filter_map (fun (m,el,p) -> match m with Meta.Custom s when String.length s > 0 && s.[0] <> ':' -> Some (s,el,p) | _ -> None) ml) l in
List.filter (fun (_,ml) -> ml <> []) l
in
let meta, fields, statics = filter meta, filter fields, filter statics in
let make_meta_field ml =
let h = Hashtbl.create 0 in
mk (TObjectDecl (List.map (fun (f,el,p) ->
if Hashtbl.mem h f then error ("Duplicate metadata '" ^ f ^ "'") p;
Hashtbl.add h f ();
f, mk (match el with [] -> TConst TNull | _ -> TArrayDecl (List.map (type_constant_value com) el)) (api.tarray t_dynamic) p
) ml)) t_dynamic p
in
let make_meta l =
mk (TObjectDecl (List.map (fun (f,ml) -> f,make_meta_field ml) l)) t_dynamic p
in
if meta = [] && fields = [] && statics = [] then
None
else
let meta_obj = [] in
let meta_obj = (if fields = [] then meta_obj else ("fields",make_meta fields) :: meta_obj) in
let meta_obj = (if statics = [] then meta_obj else ("statics",make_meta statics) :: meta_obj) in
let meta_obj = (try ("obj", make_meta_field (List.assoc "" meta)) :: meta_obj with Not_found -> meta_obj) in
Some (mk (TObjectDecl meta_obj) t_dynamic p)
(* -------------------------------------------------------------------------- *)
(* MACRO TYPE *)
let get_macro_path ctx e args p =
let rec loop e =
match fst e with
| EField (e,f) -> f :: loop e
| EConst (Ident i) -> [i]
| _ -> error "Invalid macro call" p
in
let path = match e with
| (EConst(Ident i)),_ ->
let path = try
if not (PMap.mem i ctx.curclass.cl_statics) then raise Not_found;
ctx.curclass.cl_path
with Not_found -> try
(t_infos (fst (PMap.find i ctx.m.module_globals))).mt_path
with Not_found ->
error "Invalid macro call" p
in
i :: (snd path) :: (fst path)
| _ ->
loop e
in
(match path with
| meth :: cl :: path -> (List.rev path,cl), meth, args
| _ -> error "Invalid macro call" p)
let build_macro_type ctx pl p =
let path, field, args = (match pl with
| [TInst ({ cl_kind = KExpr (ECall (e,args),_) },_)]
| [TInst ({ cl_kind = KExpr (EArrayDecl [ECall (e,args),_],_) },_)] ->
get_macro_path ctx e args p
| _ ->
error "MacroType requires a single expression call parameter" p
) in
let old = ctx.ret in
let t = (match ctx.g.do_macro ctx MMacroType path field args p with
| None -> mk_mono()
| Some _ -> ctx.ret
) in
ctx.ret <- old;
t
let build_macro_build ctx c pl cfl p =
let path, field, args = match Meta.get Meta.GenericBuild c.cl_meta with
| _,[ECall(e,args),_],_ -> get_macro_path ctx e args p
| _ -> error "genericBuild requires a single expression call parameter" p
in
let old = ctx.ret,ctx.g.get_build_infos in
ctx.g.get_build_infos <- (fun() -> Some (TClassDecl c, pl, cfl));
let t = (match ctx.g.do_macro ctx MMacroType path field args p with
| None -> mk_mono()
| Some _ -> ctx.ret
) in
ctx.ret <- fst old;
ctx.g.get_build_infos <- snd old;
t
(* -------------------------------------------------------------------------- *)
(* API EVENTS *)
let build_instance ctx mtype p =
match mtype with
| TClassDecl c ->
if ctx.pass > PBuildClass then ignore(c.cl_build());
let build f s =
let r = exc_protect ctx (fun r ->
let t = mk_mono() in
r := (fun() -> t);
unify_raise ctx (f()) t p;
t
) s in
delay ctx PForce (fun() -> ignore ((!r)()));
TLazy r
in
let ft = (fun pl ->
match c.cl_kind with
| KGeneric ->
build (fun () -> build_generic ctx c p pl) "build_generic"
| KMacroType ->
build (fun () -> build_macro_type ctx pl p) "macro_type"
| KGenericBuild cfl ->
build (fun () -> build_macro_build ctx c pl cfl p) "generic_build"
| _ ->
TInst (c,pl)
) in
c.cl_params , c.cl_path , ft
| TEnumDecl e ->
e.e_params , e.e_path , (fun t -> TEnum (e,t))
| TTypeDecl t ->
t.t_params , t.t_path , (fun tl -> TType(t,tl))
| TAbstractDecl a ->
a.a_params, a.a_path, (fun tl -> TAbstract(a,tl))
let on_inherit ctx c p h =
match h with
| HExtends { tpackage = ["haxe";"remoting"]; tname = "Proxy"; tparams = [TPType(CTPath t)] } ->
extend_remoting ctx c t p false true;
false
| HExtends { tpackage = ["haxe";"remoting"]; tname = "AsyncProxy"; tparams = [TPType(CTPath t)] } ->
extend_remoting ctx c t p true true;
false
| HExtends { tpackage = ["haxe";"xml"]; tname = "Proxy"; tparams = [TPExpr(EConst (String file),p);TPType t] } ->
extend_xml_proxy ctx c t file p;
true
| _ ->
true
(* -------------------------------------------------------------------------- *)
(* ABSTRACT CASTS *)
module AbstractCast = struct
let cast_stack = ref []
let make_static_call ctx c cf a pl args t p =
make_static_call ctx c cf (apply_params a.a_params pl) args t p
let do_check_cast ctx tleft eright p =
let recurse cf f =
if cf == ctx.curfield || List.mem cf !cast_stack then error "Recursive implicit cast" p;
cast_stack := cf :: !cast_stack;
let r = f() in
cast_stack := List.tl !cast_stack;
r
in
let find a tl f =
let tcf,cf = f() in
if (Meta.has Meta.MultiType a.a_meta) then
mk_cast eright tleft p
else match a.a_impl with
| Some c -> recurse cf (fun () ->
let ret = make_static_call ctx c cf a tl [eright] tleft p in
{ ret with eexpr = TMeta( (Meta.ImplicitCast,[],ret.epos), ret) }
)
| None -> assert false
in
if type_iseq tleft eright.etype then
eright
else begin
let rec loop tleft tright = match follow tleft,follow tright with
| TAbstract(a1,tl1),TAbstract(a2,tl2) ->
begin try find a2 tl2 (fun () -> Abstract.find_to a2 tl2 tleft)
with Not_found -> try find a1 tl1 (fun () -> Abstract.find_from a1 tl1 eright.etype tleft)
with Not_found -> raise Not_found
end
| TAbstract(a,tl),_ ->
begin try find a tl (fun () -> Abstract.find_from a tl eright.etype tleft)
with Not_found ->
let rec loop2 tcl = match tcl with
| tc :: tcl ->
if not (type_iseq tc tleft) then loop (apply_params a.a_params tl tc) tright
else loop2 tcl
| [] -> raise Not_found
in
loop2 a.a_from
end
| _,TAbstract(a,tl) ->
begin try find a tl (fun () -> Abstract.find_to a tl tleft)
with Not_found ->
let rec loop2 tcl = match tcl with
| tc :: tcl ->
if not (type_iseq tc tright) then loop tleft (apply_params a.a_params tl tc)
else loop2 tcl
| [] -> raise Not_found
in
loop2 a.a_to
end
| _ ->
raise Not_found
in
loop tleft eright.etype
end
let cast_or_unify_raise ctx tleft eright p =
try
if ctx.com.display <> DMNone then raise Not_found;
do_check_cast ctx tleft eright p
with Not_found ->
unify_raise ctx eright.etype tleft p;
eright
let cast_or_unify ctx tleft eright p =
try
cast_or_unify_raise ctx tleft eright p
with Error (Unify _ as err,_) ->
if not ctx.untyped then display_error ctx (error_msg err) p;
eright
let find_array_access_raise ctx a pl e1 e2o p =
let is_set = e2o <> None in
let ta = apply_params a.a_params pl a.a_this in
let rec loop cfl = match cfl with
| [] -> raise Not_found
| cf :: cfl when not (Ast.Meta.has Ast.Meta.ArrayAccess cf.cf_meta) ->
loop cfl
| cf :: cfl ->
let monos = List.map (fun _ -> mk_mono()) cf.cf_params in
let map t = apply_params a.a_params pl (apply_params cf.cf_params monos t) in
let check_constraints () =
List.iter2 (fun m (name,t) -> match follow t with
| TInst ({ cl_kind = KTypeParameter constr },_) when constr <> [] ->
List.iter (fun tc -> match follow m with TMono _ -> raise (Unify_error []) | _ -> Type.unify m (map tc) ) constr
| _ -> ()
) monos cf.cf_params;
in
match follow (map cf.cf_type) with
| TFun([(_,_,tab);(_,_,ta1);(_,_,ta2)],r) as tf when is_set ->
begin try
Type.unify tab ta;
let e1 = cast_or_unify_raise ctx ta1 e1 p in
let e2o = match e2o with None -> None | Some e2 -> Some (cast_or_unify_raise ctx ta2 e2 p) in
check_constraints();
cf,tf,r,e1,e2o
with Unify_error _ | Error (Unify _,_) ->
loop cfl
end
| TFun([(_,_,tab);(_,_,ta1)],r) as tf when not is_set ->
begin try
Type.unify tab ta;
let e1 = cast_or_unify_raise ctx ta1 e1 p in
check_constraints();
cf,tf,r,e1,None
with Unify_error _ | Error (Unify _,_) ->
loop cfl
end
| _ -> loop cfl
in
loop a.a_array
let find_array_access ctx a tl e1 e2o p =
try find_array_access_raise ctx a tl e1 e2o p
with Not_found -> match e2o with
| None ->
error (Printf.sprintf "No @:arrayAccess function accepts argument of %s" (s_type (print_context()) e1.etype)) p
| Some e2 ->
error (Printf.sprintf "No @:arrayAccess function accepts arguments of %s and %s" (s_type (print_context()) e1.etype) (s_type (print_context()) e2.etype)) p
let find_multitype_specialization com a pl p =
let m = mk_mono() in
let tl = match Meta.get Meta.MultiType a.a_meta with
| _,[],_ -> pl
| _,el,_ ->
let relevant = Hashtbl.create 0 in
List.iter (fun e -> match fst e with
| EConst(Ident s) -> Hashtbl.replace relevant s true
| _ -> error "Type parameter expected" (pos e)
) el;
let tl = List.map2 (fun (n,_) t -> if Hashtbl.mem relevant n || not (has_mono t) then t else t_dynamic) a.a_params pl in
if com.platform = Js && a.a_path = ([],"Map") then begin match tl with
| t1 :: _ ->
let rec loop stack t =
if List.exists (fun t2 -> fast_eq t t2) stack then
t
else begin
let stack = t :: stack in
match follow t with
| TAbstract ({ a_path = [],"Class" },_) ->
error (Printf.sprintf "Cannot use %s as key type to Map because Class is not comparable" (s_type (print_context()) t1)) p;
| TEnum(en,tl) ->
PMap.iter (fun _ ef -> ignore(loop stack ef.ef_type)) en.e_constrs;
Type.map (loop stack) t
| t ->
Type.map (loop stack) t
end
in
ignore(loop [] t1)
| _ -> assert false
end;
tl
in
let _,cf =
try
Abstract.find_to a tl m
with Not_found ->
let at = apply_params a.a_params pl a.a_this in
let st = s_type (print_context()) at in
if has_mono at then
error ("Type parameters of multi type abstracts must be known (for " ^ st ^ ")") p
else
error ("Abstract " ^ (s_type_path a.a_path) ^ " has no @:to function that accepts " ^ st) p;
in
cf, follow m
let handle_abstract_casts ctx e =
let rec loop ctx e = match e.eexpr with
| TNew({cl_kind = KAbstractImpl a} as c,pl,el) ->
(* a TNew of an abstract implementation is only generated if it is a multi type abstract *)
let cf,m = find_multitype_specialization ctx.com a pl e.epos in
let e = make_static_call ctx c cf a pl ((mk (TConst TNull) (TAbstract(a,pl)) e.epos) :: el) m e.epos in
{e with etype = m}
| TCall({eexpr = TField(_,FStatic({cl_path=[],"Std"},{cf_name = "string"}))},[e1]) when (match follow e1.etype with TAbstract({a_impl = Some _},_) -> true | _ -> false) ->
begin match follow e1.etype with
| TAbstract({a_impl = Some c} as a,tl) ->
begin try
let cf = PMap.find "toString" c.cl_statics in
make_static_call ctx c cf a tl [e1] ctx.t.tstring e.epos
with Not_found ->
e
end
| _ ->
assert false
end
| TCall(e1, el) ->
begin try
let rec find_abstract e = match follow e.etype,e.eexpr with
| TAbstract(a,pl),_ when Meta.has Meta.MultiType a.a_meta -> a,pl,e
| _,TCast(e1,None) -> find_abstract e1
| _ -> raise Not_found
in
let rec find_field e1 =
match e1.eexpr with
| TCast(e2,None) ->
{e1 with eexpr = TCast(find_field e2,None)}
| TField(e2,fa) ->
let a,pl,e2 = find_abstract e2 in
let m = Abstract.get_underlying_type a pl in
let fname = field_name fa in
let el = List.map (loop ctx) el in
begin try
let fa = quick_field m fname in
let get_fun_type t = match follow t with
| TFun(_,tr) as tf -> tf,tr
| _ -> raise Not_found
in
let tf,tr = match fa with
| FStatic(_,cf) -> get_fun_type cf.cf_type
| FInstance(c,tl,cf) -> get_fun_type (apply_params c.cl_params tl cf.cf_type)
| FAnon cf -> get_fun_type cf.cf_type
| _ -> raise Not_found
in
let ef = mk (TField({e2 with etype = m},fa)) tf e2.epos in
let ecall = make_call ctx ef el tr e.epos in
if not (type_iseq ecall.etype e.etype) then
mk (TCast(ecall,None)) e.etype e.epos
else
ecall
with Not_found ->
(* quick_field raises Not_found if m is an abstract, we have to replicate the 'using' call here *)
match follow m with
| TAbstract({a_impl = Some c} as a,pl) ->
let cf = PMap.find fname c.cl_statics in
make_static_call ctx c cf a pl (e2 :: el) e.etype e.epos
| _ -> raise Not_found
end
| _ ->
raise Not_found
in
find_field e1
with Not_found ->
Type.map_expr (loop ctx) e
end
| _ ->
Type.map_expr (loop ctx) e
in
loop ctx e
end
module PatternMatchConversion = struct
type cctx = {
ctx : typer;
mutable eval_stack : ((tvar * pos) * texpr) list list;
dt_lookup : dt array;
}
let is_declared cctx v =
let rec loop sl = match sl with
| stack :: sl ->
List.exists (fun ((v2,_),_) -> v == v2) stack || loop sl
| [] ->
false
in
loop cctx.eval_stack
let group_cases cases =
let dt_eq dt1 dt2 = match dt1,dt2 with
| DTGoto i1, DTGoto i2 when i1 = i2 -> true
(* TODO equal bindings *)
| _ -> false
in
match List.rev cases with
| [] -> []
| [con,dt] -> [[con],dt]
| (con,dt) :: cases ->
let tmp,ldt,cases = List.fold_left (fun (tmp,ldt,acc) (con,dt) ->
if dt_eq dt ldt then
(con :: tmp,dt,acc)
else
([con],dt,(tmp,ldt) :: acc)
) ([con],dt,[]) cases in
match tmp with
| [] -> cases
| tmp -> ((tmp,ldt) :: cases)
let replace_locals e =
let v_known = ref IntMap.empty in
let copy v =
let v' = alloc_var v.v_name v.v_type in
v_known := IntMap.add v.v_id v' !v_known;
v'
in
let rec loop e = match e.eexpr with
| TVar(v,e1) ->
let v' = copy v in
let e1 = match e1 with None -> None | Some e -> Some (loop e) in
{e with eexpr = TVar(v',e1)}
| TFor(v,e1,e2) ->
let v' = copy v in
let e1 = loop e1 in
let e2 = loop e2 in
{e with eexpr = TFor(v',e1,e2)}
| TTry(e1,catches) ->
let e1 = loop e1 in
let catches = List.map (fun (v,e) ->
let v' = copy v in
let e = loop e in
v',e
) catches in
{e with eexpr = TTry(e1,catches)}
| TLocal v ->
let v' = try IntMap.find v.v_id !v_known with Not_found -> v in
{e with eexpr = TLocal v'}
| _ ->
Type.map_expr loop e
in
loop e
let rec convert_dt cctx dt =
match dt with
| DTBind (bl,dt) ->
cctx.eval_stack <- bl :: cctx.eval_stack;
let e = convert_dt cctx dt in
cctx.eval_stack <- List.tl cctx.eval_stack;
let vl,el = List.fold_left (fun (vl,el) ((v,p),e) ->
if is_declared cctx v then
vl, (mk (TBinop(OpAssign,mk (TLocal v) v.v_type p,e)) e.etype e.epos) :: el
else
((v,p,Some e) :: vl), el
) ([],[e]) bl in
let el_v = List.map (fun (v,p,eo) -> mk (TVar (v,eo)) cctx.ctx.t.tvoid p) vl in
mk (TBlock (el_v @ el)) e.etype e.epos
| DTGoto i ->
convert_dt cctx (cctx.dt_lookup.(i))
| DTExpr e ->
e
| DTGuard(e,dt1,dt2) ->
let ethen = convert_dt cctx dt1 in
mk (TIf(e,ethen,match dt2 with None -> None | Some dt -> Some (convert_dt cctx dt))) ethen.etype (punion e.epos ethen.epos)
| DTSwitch({eexpr = TMeta((Meta.Exhaustive,_,_),_)},[_,dt],None) ->
convert_dt cctx dt
| DTSwitch(e_st,cl,dto) ->
let def = match dto with None -> None | Some dt -> Some (convert_dt cctx dt) in
let cases = group_cases cl in
let cases = List.map (fun (cl,dt) ->
let e = convert_dt cctx dt in
(* The macro interpreter does not care about unique locals and
we don't run the analyzer on the output, so let's save some
time here (issue #3937) *)
let e = if cctx.ctx.in_macro then e else replace_locals e in
cl,e
) cases in
mk (TSwitch(e_st,cases,def)) (mk_mono()) e_st.epos
let to_typed_ast ctx dt p =
let first = dt.dt_dt_lookup.(dt.dt_first) in
let cctx = {
ctx = ctx;
dt_lookup = dt.dt_dt_lookup;
eval_stack = [];
} in
let e = convert_dt cctx first in
let e = { e with epos = p; etype = dt.dt_type} in
if dt.dt_var_init = [] then
e
else begin
let el_v = List.map (fun (v,eo) -> mk (TVar (v,eo)) cctx.ctx.t.tvoid p) dt.dt_var_init in
mk (TBlock (el_v @ [e])) dt.dt_type e.epos
end
end
(* -------------------------------------------------------------------------- *)
(* USAGE *)
let detect_usage com =
let usage = ref [] in
List.iter (fun t -> match t with
| TClassDecl c ->
let check_constructor c p =
try
let _,cf = get_constructor (fun cf -> cf.cf_type) c in
if Meta.has Meta.Usage cf.cf_meta then
usage := p :: !usage;
with Not_found ->
()
in
let rec expr e = match e.eexpr with
| TField(_,FEnum(_,ef)) when Meta.has Meta.Usage ef.ef_meta ->
let p = {e.epos with pmin = e.epos.pmax - (String.length ef.ef_name)} in
usage := p :: !usage;
Type.iter expr e
| TField(_,(FAnon cf | FInstance (_,_,cf) | FStatic (_,cf) | FClosure (_,cf))) when Meta.has Meta.Usage cf.cf_meta ->
let p = {e.epos with pmin = e.epos.pmax - (String.length cf.cf_name)} in
usage := p :: !usage;
Type.iter expr e
| TLocal v when Meta.has Meta.Usage v.v_meta ->
usage := e.epos :: !usage
| TVar (v,_) when com.display = DMPosition && Meta.has Meta.Usage v.v_meta ->
raise (Typecore.DisplayPosition [e.epos])
| TFunction tf when com.display = DMPosition && List.exists (fun (v,_) -> Meta.has Meta.Usage v.v_meta) tf.tf_args ->
raise (Typecore.DisplayPosition [e.epos])
| TTypeExpr mt when (Meta.has Meta.Usage (t_infos mt).mt_meta) ->
usage := e.epos :: !usage
| TNew (c,_,_) ->
check_constructor c e.epos;
Type.iter expr e;
| TCall({eexpr = TConst TSuper},_) ->
begin match c.cl_super with
| Some (c,_) ->
check_constructor c e.epos
| _ ->
()
end
| _ -> Type.iter expr e
in
let field cf = ignore(follow cf.cf_type); match cf.cf_expr with None -> () | Some e -> expr e in
(match c.cl_constructor with None -> () | Some cf -> field cf);
(match c.cl_init with None -> () | Some e -> expr e);
List.iter field c.cl_ordered_statics;
List.iter field c.cl_ordered_fields;
| _ -> ()
) com.types;
let usage = List.sort (fun p1 p2 ->
let c = compare p1.pfile p2.pfile in
if c <> 0 then c else compare p1.pmin p2.pmin
) !usage in
raise (Typecore.DisplayPosition usage)
let update_cache_dependencies com =
let rec check_t m t = match t with
| TInst(c,tl) ->
add_dependency m c.cl_module;
List.iter (check_t m) tl;
| TEnum(en,tl) ->
add_dependency m en.e_module;
List.iter (check_t m) tl;
| TType(t,tl) ->
add_dependency m t.t_module;
List.iter (check_t m) tl;
| TAbstract(a,tl) ->
add_dependency m a.a_module;
List.iter (check_t m) tl;
| TFun(targs,tret) ->
List.iter (fun (_,_,t) -> check_t m t) targs;
check_t m tret;
| TAnon an ->
PMap.iter (fun _ cf -> check_field m cf) an.a_fields
| TMono r ->
(match !r with
| Some t -> check_t m t
| _ -> ())
| TLazy f ->
check_t m (!f())
| TDynamic t ->
if t == t_dynamic then
()
else
check_t m t
and check_field m cf =
check_t m cf.cf_type
in
List.iter (fun t -> match t with
| TClassDecl c ->
List.iter (check_field c.cl_module) c.cl_ordered_statics;
List.iter (check_field c.cl_module) c.cl_ordered_fields;
(match c.cl_constructor with None -> () | Some cf -> check_field c.cl_module cf);
| _ ->
()
) com.types
(* -------------------------------------------------------------------------- *)
(* STACK MANAGEMENT EMULATION *)
type stack_context = {
stack_var : string;
stack_exc_var : string;
stack_pos_var : string;
stack_pos : pos;
stack_expr : texpr;
stack_pop : texpr;
stack_save_pos : texpr;
stack_restore : texpr list;
stack_push : tclass -> string -> texpr;
stack_return : texpr -> texpr;
}
let stack_context_init com stack_var exc_var pos_var tmp_var use_add p =
let t = com.basic in
let st = t.tarray t.tstring in
let stack_var = alloc_var stack_var st in
let exc_var = alloc_var exc_var st in
let pos_var = alloc_var pos_var t.tint in
let stack_e = mk (TLocal stack_var) st p in
let exc_e = mk (TLocal exc_var) st p in
let stack_pop = fcall stack_e "pop" [] t.tstring p in
let stack_push c m =
fcall stack_e "push" [
if use_add then
binop OpAdd (string com (s_type_path c.cl_path ^ "::") p) (string com m p) t.tstring p
else
string com (s_type_path c.cl_path ^ "::" ^ m) p
] t.tvoid p
in
let stack_return e =
let tmp = alloc_var tmp_var e.etype in
mk (TBlock [
mk (TVar (tmp, Some e)) t.tvoid e.epos;
stack_pop;
mk (TReturn (Some (mk (TLocal tmp) e.etype e.epos))) e.etype e.epos
]) e.etype e.epos
in
{
stack_var = stack_var.v_name;
stack_exc_var = exc_var.v_name;
stack_pos_var = pos_var.v_name;
stack_pos = p;
stack_expr = stack_e;
stack_pop = stack_pop;
stack_save_pos = mk (TVar (pos_var, Some (field stack_e "length" t.tint p))) t.tvoid p;
stack_push = stack_push;
stack_return = stack_return;
stack_restore = [
binop OpAssign exc_e (mk (TArrayDecl []) st p) st p;
mk (TWhile (
mk_parent (binop OpGte (field stack_e "length" t.tint p) (mk (TLocal pos_var) t.tint p) t.tbool p),
fcall exc_e "unshift" [fcall stack_e "pop" [] t.tstring p] t.tvoid p,
NormalWhile
)) t.tvoid p;
fcall stack_e "push" [index com exc_e 0 t.tstring p] t.tvoid p
];
}
let stack_init com use_add =
stack_context_init com "$s" "$e" "$spos" "$tmp" use_add null_pos
let rec stack_block_loop ctx e =
match e.eexpr with
| TFunction _ ->
e
| TReturn None | TReturn (Some { eexpr = TConst _ }) | TReturn (Some { eexpr = TLocal _ }) ->
mk (TBlock [
ctx.stack_pop;
e;
]) e.etype e.epos
| TReturn (Some e) ->
ctx.stack_return (stack_block_loop ctx e)
| TTry (v,cases) ->
let v = stack_block_loop ctx v in
let cases = List.map (fun (v,e) ->
let e = stack_block_loop ctx e in
let e = (match (mk_block e).eexpr with
| TBlock l -> mk (TBlock (ctx.stack_restore @ l)) e.etype e.epos
| _ -> assert false
) in
v , e
) cases in
mk (TTry (v,cases)) e.etype e.epos
| _ ->
map_expr (stack_block_loop ctx) e
let stack_block ctx c m e =
match (mk_block e).eexpr with
| TBlock l ->
mk (TBlock (
ctx.stack_push c m ::
ctx.stack_save_pos ::
List.map (stack_block_loop ctx) l
@ [ctx.stack_pop]
)) e.etype e.epos
| _ ->
assert false
(* -------------------------------------------------------------------------- *)
(* FIX OVERRIDES *)
(*
on some platforms which doesn't support type parameters, we must have the
exact same type for overriden/implemented function as the original one
*)
let rec find_field com c f =
try
(match c.cl_super with
| None ->
raise Not_found
| Some ( {cl_path = (["cpp"],"FastIterator")}, _ ) ->
raise Not_found (* This is a strongly typed 'extern' and the usual rules don't apply *)
| Some (c,_) ->
find_field com c f)
with Not_found -> try
if com.platform = Cpp then (* Cpp uses delegation for interfaces *)
raise Not_found;
let rec loop = function
| [] ->
raise Not_found
| (c,_) :: l ->
try
find_field com c f
with
Not_found -> loop l
in
loop c.cl_implements
with Not_found ->
let f = PMap.find f.cf_name c.cl_fields in
(match f.cf_kind with Var { v_read = AccRequire _ } -> raise Not_found | _ -> ());
f
let fix_override com c f fd =
let f2 = (try Some (find_field com c f) with Not_found -> None) in
match f2,fd with
| Some (f2), Some(fd) ->
let targs, tret = (match follow f2.cf_type with TFun (args,ret) -> args, ret | _ -> assert false) in
let changed_args = ref [] in
let prefix = "_tmp_" in
let nargs = List.map2 (fun ((v,ct) as cur) (_,_,t2) ->
try
type_eq EqStrict (monomorphs c.cl_params (monomorphs f.cf_params v.v_type)) t2;
(* Flash generates type parameters with a single constraint as that constraint type, so we
have to detect this case and change the variable (issue #2712). *)
begin match follow v.v_type with
| TInst({cl_kind = KTypeParameter [tc]} as cp,_) when com.platform = Flash ->
if List.mem_assoc (snd cp.cl_path) c.cl_params then raise (Unify_error [])
| _ ->
()
end;
cur
with Unify_error _ ->
let v2 = alloc_var (prefix ^ v.v_name) t2 in
changed_args := (v,v2) :: !changed_args;
v2,ct
) fd.tf_args targs in
let fd2 = {
tf_args = nargs;
tf_type = tret;
tf_expr = (match List.rev !changed_args with
| [] -> fd.tf_expr
| args ->
let e = fd.tf_expr in
let el = (match e.eexpr with TBlock el -> el | _ -> [e]) in
let p = (match el with [] -> e.epos | e :: _ -> e.epos) in
let el_v = List.map (fun (v,v2) ->
mk (TVar (v,Some (mk (TCast (mk (TLocal v2) v2.v_type p,None)) v.v_type p))) com.basic.tvoid p
) args in
{ e with eexpr = TBlock (el_v @ el) }
);
} in
(* as3 does not allow wider visibility, so the base method has to be made public *)
if Common.defined com Define.As3 && f.cf_public then f2.cf_public <- true;
let targs = List.map (fun(v,c) -> (v.v_name, Option.is_some c, v.v_type)) nargs in
let fde = (match f.cf_expr with None -> assert false | Some e -> e) in
f.cf_expr <- Some { fde with eexpr = TFunction fd2 };
f.cf_type <- TFun(targs,tret);
| Some(f2), None when c.cl_interface ->
let targs, tret = (match follow f2.cf_type with TFun (args,ret) -> args, ret | _ -> assert false) in
f.cf_type <- TFun(targs,tret)
| _ ->
()
let fix_overrides com t =
match t with
| TClassDecl c ->
(* overrides can be removed from interfaces *)
if c.cl_interface then
c.cl_ordered_fields <- List.filter (fun f ->
try
if find_field com c f == f then raise Not_found;
c.cl_fields <- PMap.remove f.cf_name c.cl_fields;
false;
with Not_found ->
true
) c.cl_ordered_fields;
List.iter (fun f ->
match f.cf_expr, f.cf_kind with
| Some { eexpr = TFunction fd }, Method (MethNormal | MethInline) ->
fix_override com c f (Some fd)
| None, Method (MethNormal | MethInline) when c.cl_interface ->
fix_override com c f None
| _ ->
()
) c.cl_ordered_fields
| _ ->
()
(*
PHP does not allow abstract classes extending other abstract classes to override any fields, so these duplicates
must be removed from the child interface
*)
let fix_abstract_inheritance com t =
match t with
| TClassDecl c when c.cl_interface ->
c.cl_ordered_fields <- List.filter (fun f ->
let b = try (find_field com c f) == f
with Not_found -> false in
if not b then c.cl_fields <- PMap.remove f.cf_name c.cl_fields;
b;
) c.cl_ordered_fields
| _ -> ()
(* -------------------------------------------------------------------------- *)
(* MISC FEATURES *)
let rec is_volatile t =
match t with
| TMono r ->
(match !r with
| Some t -> is_volatile t
| _ -> false)
| TLazy f ->
is_volatile (!f())
| TType (t,tl) ->
(match t.t_path with
| _ -> is_volatile (apply_params t.t_params tl t.t_type))
| _ ->
false
let set_default ctx a c p =
let t = a.v_type in
let ve = mk (TLocal a) t p in
let cond = TBinop (OpEq,ve,mk (TConst TNull) t p) in
mk (TIf (mk_parent (mk cond ctx.basic.tbool p), mk (TBinop (OpAssign,ve,mk (TConst c) t p)) t p,None)) ctx.basic.tvoid p
let bytes_serialize data =
let b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" in
let tbl = Array.init (String.length b64) (fun i -> String.get b64 i) in
Base64.str_encode ~tbl data
(*
Tells if the constructor might be called without any issue whatever its parameters
*)
let rec constructor_side_effects e =
match e.eexpr with
| TBinop (op,_,_) when op <> OpAssign ->
true
| TField (_,FEnum _) ->
false
| TUnop _ | TArray _ | TField _ | TEnumParameter _ | TCall _ | TNew _ | TFor _ | TWhile _ | TSwitch _ | TReturn _ | TThrow _ ->
true
| TBinop _ | TTry _ | TIf _ | TBlock _ | TVar _
| TFunction _ | TArrayDecl _ | TObjectDecl _
| TParenthesis _ | TTypeExpr _ | TLocal _ | TMeta _
| TConst _ | TContinue | TBreak | TCast _ ->
try
Type.iter (fun e -> if constructor_side_effects e then raise Exit) e;
false;
with Exit ->
true
let make_valid_filename s =
let r = Str.regexp "[^A-Za-z0-9_\\-\\.,]" in
Str.global_substitute r (fun s -> "_") s
(*
Make a dump of the full typed AST of all types
*)
let rec create_dumpfile acc = function
| [] -> assert false
| d :: [] ->
let d = make_valid_filename d in
let ch = open_out (String.concat "/" (List.rev (d :: acc)) ^ ".dump") in
let buf = Buffer.create 0 in
buf, (fun () ->
output_string ch (Buffer.contents buf);
close_out ch)
| d :: l ->
let dir = String.concat "/" (List.rev (d :: acc)) in
if not (Sys.file_exists dir) then Unix.mkdir dir 0o755;
create_dumpfile (d :: acc) l
let dump_types com =
let s_type = s_type (Type.print_context()) in
let params = function [] -> "" | l -> Printf.sprintf "<%s>" (String.concat "," (List.map (fun (n,t) -> n ^ " : " ^ s_type t) l)) in
let s_expr = match Common.defined_value_safe com Define.Dump with
| "pretty" -> Type.s_expr_pretty "\t"
| "legacy" -> Type.s_expr
| _ -> Type.s_expr_ast (not (Common.defined com Define.DumpIgnoreVarIds)) "\t"
in
List.iter (fun mt ->
let path = Type.t_path mt in
let buf,close = create_dumpfile [] ("dump" :: (Common.platform_name com.platform) :: fst path @ [snd path]) in
let print fmt = Printf.kprintf (fun s -> Buffer.add_string buf s) fmt in
(match mt with
| Type.TClassDecl c ->
let rec print_field stat f =
print "\t%s%s%s%s" (if stat then "static " else "") (if f.cf_public then "public " else "") f.cf_name (params f.cf_params);
print "(%s) : %s" (s_kind f.cf_kind) (s_type f.cf_type);
(match f.cf_expr with
| None -> ()
| Some e -> print "\n\n\t = %s" (s_expr s_type e));
print "\n\n";
List.iter (fun f -> print_field stat f) f.cf_overloads
in
print "%s%s%s %s%s" (if c.cl_private then "private " else "") (if c.cl_extern then "extern " else "") (if c.cl_interface then "interface" else "class") (s_type_path path) (params c.cl_params);
(match c.cl_super with None -> () | Some (c,pl) -> print " extends %s" (s_type (TInst (c,pl))));
List.iter (fun (c,pl) -> print " implements %s" (s_type (TInst (c,pl)))) c.cl_implements;
(match c.cl_dynamic with None -> () | Some t -> print " implements Dynamic<%s>" (s_type t));
(match c.cl_array_access with None -> () | Some t -> print " implements ArrayAccess<%s>" (s_type t));
print "{\n";
(match c.cl_constructor with
| None -> ()
| Some f -> print_field false f);
List.iter (print_field false) c.cl_ordered_fields;
List.iter (print_field true) c.cl_ordered_statics;
(match c.cl_init with
| None -> ()
| Some e ->
print "\n\n\t__init__ = ";
print "%s" (s_expr s_type e);
print "}\n");
print "}";
| Type.TEnumDecl e ->
print "%s%senum %s%s {\n" (if e.e_private then "private " else "") (if e.e_extern then "extern " else "") (s_type_path path) (params e.e_params);
List.iter (fun n ->
let f = PMap.find n e.e_constrs in
print "\t%s : %s;\n" f.ef_name (s_type f.ef_type);
) e.e_names;
print "}"
| Type.TTypeDecl t ->
print "%stype %s%s = %s" (if t.t_private then "private " else "") (s_type_path path) (params t.t_params) (s_type t.t_type);
| Type.TAbstractDecl a ->
print "%sabstract %s%s {}" (if a.a_private then "private " else "") (s_type_path path) (params a.a_params);
);
close();
) com.types
let dump_dependencies com =
let buf,close = create_dumpfile [] ["dump";Common.platform_name com.platform;".dependencies"] in
let print fmt = Printf.kprintf (fun s -> Buffer.add_string buf s) fmt in
let dep = Hashtbl.create 0 in
List.iter (fun m ->
print "%s:\n" m.m_extra.m_file;
PMap.iter (fun _ m2 ->
print "\t%s\n" (m2.m_extra.m_file);
let l = try Hashtbl.find dep m2.m_extra.m_file with Not_found -> [] in
Hashtbl.replace dep m2.m_extra.m_file (m :: l)
) m.m_extra.m_deps;
) com.Common.modules;
close();
let buf,close = create_dumpfile [] ["dump";Common.platform_name com.platform;".dependants"] in
let print fmt = Printf.kprintf (fun s -> Buffer.add_string buf s) fmt in
Hashtbl.iter (fun n ml ->
print "%s:\n" n;
List.iter (fun m ->
print "\t%s\n" (m.m_extra.m_file);
) ml;
) dep;
close()
(*
Build a default safe-cast expression :
{ var $t = ; if( Std.is($t,) ) $t else throw "Class cast error"; }
*)
let default_cast ?(vtmp="$t") com e texpr t p =
let api = com.basic in
let mk_texpr = function
| TClassDecl c -> TAnon { a_fields = PMap.empty; a_status = ref (Statics c) }
| TEnumDecl e -> TAnon { a_fields = PMap.empty; a_status = ref (EnumStatics e) }
| TAbstractDecl a -> TAnon { a_fields = PMap.empty; a_status = ref (AbstractStatics a) }
| TTypeDecl _ -> assert false
in
let vtmp = alloc_var vtmp e.etype in
let var = mk (TVar (vtmp,Some e)) api.tvoid p in
let vexpr = mk (TLocal vtmp) e.etype p in
let texpr = mk (TTypeExpr texpr) (mk_texpr texpr) p in
let std = (try List.find (fun t -> t_path t = ([],"Std")) com.types with Not_found -> assert false) in
let fis = (try
let c = (match std with TClassDecl c -> c | _ -> assert false) in
FStatic (c, PMap.find "is" c.cl_statics)
with Not_found ->
assert false
) in
let std = mk (TTypeExpr std) (mk_texpr std) p in
let is = mk (TField (std,fis)) (tfun [t_dynamic;t_dynamic] api.tbool) p in
let is = mk (TCall (is,[vexpr;texpr])) api.tbool p in
let exc = mk (TThrow (mk (TConst (TString "Class cast error")) api.tstring p)) t p in
let check = mk (TIf (mk_parent is,mk (TCast (vexpr,None)) t p,Some exc)) t p in
mk (TBlock [var;check;vexpr]) t p
(** Overload resolution **)
module Overloads =
struct
let rec simplify_t t = match t with
| TAbstract(a,_) when Meta.has Meta.CoreType a.a_meta ->
t
| TInst _ | TEnum _ ->
t
| TAbstract(a,tl) -> simplify_t (Abstract.get_underlying_type a tl)
| TType(({ t_path = [],"Null" } as t), [t2]) -> (match simplify_t t2 with
| (TAbstract(a,_) as t2) when Meta.has Meta.CoreType a.a_meta ->
TType(t, [simplify_t t2])
| (TEnum _ as t2) ->
TType(t, [simplify_t t2])
| t2 -> t2)
| TType(t, tl) ->
simplify_t (apply_params t.t_params tl t.t_type)
| TMono r -> (match !r with
| Some t -> simplify_t t
| None -> t_dynamic)
| TAnon _ -> t_dynamic
| TDynamic _ -> t
| TLazy f -> simplify_t (!f())
| TFun _ -> t
(* rate type parameters *)
let rate_tp tlfun tlarg =
let acc = ref 0 in
List.iter2 (fun f a -> if not (type_iseq f a) then incr acc) tlfun tlarg;
!acc
(**
The rate function returns an ( int * int ) type.
The smaller the int, the best rated the caller argument is in comparison with the callee.
The first int refers to how many "conversions" would be necessary to convert from the callee to the caller type, and
the second refers to the type parameters.
**)
let rec rate_conv cacc tfun targ =
match simplify_t tfun, simplify_t targ with
| TInst({ cl_interface = true } as cf, tlf), TInst(ca, tla) ->
(* breadth-first *)
let stack = ref [0,ca,tla] in
let cur = ref (0, ca,tla) in
let rec loop () =
match !stack with
| [] -> (let acc, ca, tla = !cur in match ca.cl_super with
| None -> raise Not_found
| Some (sup,tls) ->
cur := (acc+1,sup,List.map (apply_params ca.cl_params tla) tls);
stack := [!cur];
loop())
| (acc,ca,tla) :: _ when ca == cf ->
acc,tla
| (acc,ca,tla) :: s ->
stack := s @ List.map (fun (c,tl) -> (acc+1,c,List.map (apply_params ca.cl_params tla) tl)) ca.cl_implements;
loop()
in
let acc, tla = loop() in
(cacc + acc, rate_tp tlf tla)
| TInst(cf,tlf), TInst(ca,tla) ->
let rec loop acc ca tla =
if cf == ca then
acc, tla
else match ca.cl_super with
| None -> raise Not_found
| Some(sup,stl) ->
loop (acc+1) sup (List.map (apply_params ca.cl_params tla) stl)
in
let acc, tla = loop 0 ca tla in
(cacc + acc, rate_tp tlf tla)
| TEnum(ef,tlf), TEnum(ea, tla) ->
if ef != ea then raise Not_found;
(cacc, rate_tp tlf tla)
| TDynamic _, TDynamic _ ->
(cacc, 0)
| TDynamic _, _ ->
(max_int, 0) (* a function with dynamic will always be worst of all *)
| TAbstract(a, _), TDynamic _ when Meta.has Meta.CoreType a.a_meta ->
(cacc + 2, 0) (* a dynamic to a basic type will have an "unboxing" penalty *)
| _, TDynamic _ ->
(cacc + 1, 0)
| TAbstract(af,tlf), TAbstract(aa,tla) ->
(if af == aa then
(cacc, rate_tp tlf tla)
else
let ret = ref None in
if List.exists (fun t -> try
ret := Some (rate_conv (cacc+1) (apply_params af.a_params tlf t) targ);
true
with | Not_found ->
false
) af.a_from then
Option.get !ret
else
if List.exists (fun t -> try
ret := Some (rate_conv (cacc+1) tfun (apply_params aa.a_params tla t));
true
with | Not_found ->
false
) aa.a_to then
Option.get !ret
else
raise Not_found)
| TType({ t_path = [], "Null" }, [tf]), TType({ t_path = [], "Null" }, [ta]) ->
rate_conv (cacc+0) tf ta
| TType({ t_path = [], "Null" }, [tf]), ta ->
rate_conv (cacc+1) tf ta
| tf, TType({ t_path = [], "Null" }, [ta]) ->
rate_conv (cacc+1) tf ta
| TFun _, TFun _ -> (* unify will make sure they are compatible *)
cacc,0
| tfun,targ ->
raise Not_found
let is_best arg1 arg2 =
(List.for_all2 (fun v1 v2 ->
v1 <= v2)
arg1 arg2) && (List.exists2 (fun v1 v2 ->
v1 < v2)
arg1 arg2)
let rec rm_duplicates acc ret = match ret with
| [] -> acc
| ( el, t, _ ) :: ret when List.exists (fun (_,t2,_) -> type_iseq t t2) acc ->
rm_duplicates acc ret
| r :: ret ->
rm_duplicates (r :: acc) ret
let s_options rated =
String.concat ",\n" (List.map (fun ((elist,t,_),rate) ->
"( " ^ (String.concat "," (List.map (fun(e,_) -> s_expr (s_type (print_context())) e) elist)) ^ " ) => " ^
"( " ^ (String.concat "," (List.map (fun (i,i2) -> string_of_int i ^ ":" ^ string_of_int i2) rate)) ^ " ) => " ^ (s_type (print_context()) t)
) rated)
let count_optionals elist =
List.fold_left (fun acc (_,is_optional) -> if is_optional then acc + 1 else acc) 0 elist
let rec fewer_optionals acc compatible = match acc, compatible with
| _, [] -> acc
| [], c :: comp -> fewer_optionals [c] comp
| (elist_acc, _, _) :: _, ((elist, _, _) as cur) :: comp ->
let acc_opt = count_optionals elist_acc in
let comp_opt = count_optionals elist in
if acc_opt = comp_opt then
fewer_optionals (cur :: acc) comp
else if acc_opt < comp_opt then
fewer_optionals acc comp
else
fewer_optionals [cur] comp
let reduce_compatible compatible = match fewer_optionals [] (rm_duplicates [] compatible) with
| [] -> []
| [v] -> [v]
| compatible ->
(* convert compatible into ( rate * compatible_type ) list *)
let rec mk_rate acc elist args = match elist, args with
| [], [] -> acc
| (_,true) :: elist, _ :: args -> mk_rate acc elist args
| (e,false) :: elist, (n,o,t) :: args ->
(* if the argument is an implicit cast, we need to start with a penalty *)
(* The penalty should be higher than any other implicit cast - other than Dynamic *)
(* since Dynamic has a penalty of max_int, we'll impose max_int - 1 to it *)
(match e.eexpr with
| TMeta( (Meta.ImplicitCast,_,_), _) ->
mk_rate ((max_int - 1, 0) :: acc) elist args
| _ ->
mk_rate (rate_conv 0 t e.etype :: acc) elist args)
| _ -> assert false
in
let rated = ref [] in
List.iter (function
| (elist,TFun(args,ret),d) -> (try
rated := ( (elist,TFun(args,ret),d), mk_rate [] elist args ) :: !rated
with | Not_found -> ())
| _ -> assert false
) compatible;
let rec loop best rem = match best, rem with
| _, [] -> best
| [], r1 :: rem -> loop [r1] rem
| (bover, bargs) :: b1, (rover, rargs) :: rem ->
if is_best bargs rargs then
loop best rem
else if is_best rargs bargs then
loop (loop b1 [rover,rargs]) rem
else (* equally specific *)
loop ( (rover,rargs) :: best ) rem
in
let r = loop [] !rated in
List.map fst r
end;;
module UnificationCallback = struct
let tf_stack = ref []
let check_call_params f el tl =
let rec loop acc el tl = match el,tl with
| e :: el, (n,_,t) :: tl ->
loop ((f e t) :: acc) el tl
| [], [] ->
acc
| [],_ ->
acc
| e :: el, [] ->
loop (e :: acc) el []
in
List.rev (loop [] el tl)
let check_call f el t = match follow t with
| TFun(args,_) ->
check_call_params f el args
| _ ->
List.map (fun e -> f e t_dynamic) el
let rec run f e =
let f e t =
(* TODO: I don't think this should cause errors on Flash target *)
(* if not (type_iseq e.etype t) then f e t else e *)
f e t
in
let check e = match e.eexpr with
| TBinop((OpAssign | OpAssignOp _ as op),e1,e2) ->
let e2 = f e2 e1.etype in
{e with eexpr = TBinop(op,e1,e2)}
| TVar(v,Some ev) ->
let eo = Some (f ev v.v_type) in
{ e with eexpr = TVar(v,eo) }
| TCall(e1,el) ->
let el = check_call f el e1.etype in
{e with eexpr = TCall(e1,el)}
| TNew(c,tl,el) ->
begin try
let tcf,_ = get_constructor (fun cf -> apply_params c.cl_params tl cf.cf_type) c in
let el = check_call f el tcf in
{e with eexpr = TNew(c,tl,el)}
with Not_found ->
e
end
| TArrayDecl el ->
begin match follow e.etype with
| TInst({cl_path=[],"Array"},[t]) -> {e with eexpr = TArrayDecl(List.map (fun e -> f e t) el)}
| _ -> e
end
| TObjectDecl fl ->
begin match follow e.etype with
| TAnon an ->
let fl = List.map (fun (n,e) ->
let e = try
let t = (PMap.find n an.a_fields).cf_type in
f e t
with Not_found ->
e
in
n,e
) fl in
{ e with eexpr = TObjectDecl fl }
| _ -> e
end
| TReturn (Some e1) ->
begin match !tf_stack with
| tf :: _ -> { e with eexpr = TReturn (Some (f e1 tf.tf_type))}
| _ -> e
end
| _ ->
e
in
match e.eexpr with
| TFunction tf ->
tf_stack := tf :: !tf_stack;
let etf = {e with eexpr = TFunction({tf with tf_expr = run f tf.tf_expr})} in
tf_stack := List.tl !tf_stack;
etf
| _ ->
check (Type.map_expr (run f) e)
end;;
module DeprecationCheck = struct
let curclass = ref null_class
let warned_positions = Hashtbl.create 0
let print_deprecation_message com meta s p_usage =
let s = match meta with
| _,[EConst(String s),_],_ -> s
| _ -> Printf.sprintf "Usage of this %s is deprecated" s
in
if not (Hashtbl.mem warned_positions p_usage) then begin
Hashtbl.replace warned_positions p_usage true;
com.warning s p_usage;
end
let check_meta com meta s p_usage =
try
print_deprecation_message com (Meta.get Meta.Deprecated meta) s p_usage;
with Not_found ->
()
let check_cf com cf p = check_meta com cf.cf_meta "field" p
let check_class com c p = if c != !curclass then check_meta com c.cl_meta "class" p
let check_enum com en p = check_meta com en.e_meta "enum" p
let check_ef com ef p = check_meta com ef.ef_meta "enum field" p
let check_typedef com t p = check_meta com t.t_meta "typedef" p
let check_module_type com mt p = match mt with
| TClassDecl c -> check_class com c p
| TEnumDecl en -> check_enum com en p
| _ -> ()
let run com =
let rec expr e = match e.eexpr with
| TField(e1,fa) ->
expr e1;
begin match fa with
| FStatic(c,cf) | FInstance(c,_,cf) ->
check_class com c e.epos;
check_cf com cf e.epos
| FAnon cf ->
check_cf com cf e.epos
| FClosure(co,cf) ->
(match co with None -> () | Some (c,_) -> check_class com c e.epos);
check_cf com cf e.epos
| FEnum(en,ef) ->
check_enum com en e.epos;
check_ef com ef e.epos;
| _ ->
()
end
| TNew(c,_,el) ->
List.iter expr el;
check_class com c e.epos;
(match c.cl_constructor with None -> () | Some cf -> check_cf com cf e.epos)
| TTypeExpr(mt) | TCast(_,Some mt) ->
check_module_type com mt e.epos
| TMeta((Meta.Deprecated,_,_) as meta,e1) ->
print_deprecation_message com meta "field" e1.epos;
expr e1;
| _ ->
Type.iter expr e
in
List.iter (fun t -> match t with
| TClassDecl c ->
curclass := c;
let field cf = match cf.cf_expr with None -> () | Some e -> expr e in
(match c.cl_constructor with None -> () | Some cf -> field cf);
(match c.cl_init with None -> () | Some e -> expr e);
List.iter field c.cl_ordered_statics;
List.iter field c.cl_ordered_fields;
| _ ->
()
) com.types
end
let interpolate_code com code tl f_string f_expr p =
let exprs = Array.of_list tl in
let i = ref 0 in
let err msg =
let pos = { p with pmin = p.pmin + !i } in
com.error msg pos
in
let regex = Str.regexp "[{}]" in
let rec loop m = match m with
| [] ->
()
| Str.Text txt :: tl ->
i := !i + String.length txt;
f_string txt;
loop tl
| Str.Delim a :: Str.Delim b :: tl when a = b ->
i := !i + 2;
f_string a;
loop tl
| Str.Delim "{" :: Str.Text n :: Str.Delim "}" :: tl ->
(try
let expr = Array.get exprs (int_of_string n) in
f_expr expr;
i := !i + 2 + String.length n;
loop tl
with
| Failure "int_of_string" ->
err ("Index expected. Got " ^ n)
| Invalid_argument _ ->
err ("Out-of-bounds special parameter: " ^ n))
| Str.Delim x :: _ ->
err ("Unexpected " ^ x)
in
loop (Str.full_split regex code)
haxe_3.2.1+dfsg.orig/common.ml 0000664 0001750 0001750 00000131475 12607337712 016161 0 ustar andy andy 0000000 0000000 (*
* Copyright (C)2005-2013 Haxe Foundation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*)
open Ast
open Type
type package_rule =
| Forbidden
| Directory of string
| Remap of string
type pos = Ast.pos
type basic_types = {
mutable tvoid : t;
mutable tint : t;
mutable tfloat : t;
mutable tbool : t;
mutable tnull : t -> t;
mutable tstring : t;
mutable tarray : t -> t;
}
type stats = {
s_files_parsed : int ref;
s_classes_built : int ref;
s_methods_typed : int ref;
s_macros_called : int ref;
}
type platform =
| Cross
| Js
| Neko
| Flash
| Php
| Cpp
| Cs
| Java
| Python
(**
The capture policy tells which handling we make of captured locals
(the locals which are referenced in local functions)
See details/implementation in Codegen.captured_vars
*)
type capture_policy =
(** do nothing, let the platform handle it *)
| CPNone
(** wrap all captured variables into a single-element array to allow modifications *)
| CPWrapRef
(** similar to wrap ref, but will only apply to the locals that are declared in loops *)
| CPLoopVars
type platform_config = {
(** has a static type system, with not-nullable basic types (Int/Float/Bool) *)
pf_static : bool;
(** has access to the "sys" package *)
pf_sys : bool;
(** local variables are block-scoped *)
pf_locals_scope : bool;
(** captured local variables are scoped *)
pf_captured_scope : bool;
(** generated locals must be absolutely unique wrt the current function *)
pf_unique_locals : bool;
(** captured variables handling (see before) *)
pf_capture_policy : capture_policy;
(** when calling a method with optional args, do we replace the missing args with "null" constants *)
pf_pad_nulls : bool;
(** add a final return to methods not having one already - prevent some compiler warnings *)
pf_add_final_return : bool;
(** does the platform natively support overloaded functions *)
pf_overload : bool;
(** does the platform generator handle pattern matching *)
pf_pattern_matching : bool;
(** can the platform use default values for non-nullable arguments *)
pf_can_skip_non_nullable_argument : bool;
(** type paths that are reserved on the platform *)
pf_reserved_type_paths : path list;
}
type display_mode =
| DMNone
| DMDefault
| DMUsage
| DMPosition
| DMToplevel
| DMResolve of string
| DMType
type context = {
(* config *)
version : int;
args : string list;
mutable sys_args : string list;
mutable display : display_mode;
mutable debug : bool;
mutable verbose : bool;
mutable foptimize : bool;
mutable platform : platform;
mutable config : platform_config;
mutable std_path : string list;
mutable class_path : string list;
mutable main_class : Type.path option;
mutable defines : (string,string) PMap.t;
mutable package_rules : (string,package_rule) PMap.t;
mutable error : string -> pos -> unit;
mutable warning : string -> pos -> unit;
mutable load_extern_type : (path -> pos -> (string * Ast.package) option) list; (* allow finding types which are not in sources *)
mutable filters : (unit -> unit) list;
mutable final_filters : (unit -> unit) list;
mutable defines_signature : string option;
mutable print : string -> unit;
mutable get_macros : unit -> context option;
mutable run_command : string -> int;
file_lookup_cache : (string,string option) Hashtbl.t;
mutable stored_typed_exprs : (int, texpr) PMap.t;
(* output *)
mutable file : string;
mutable flash_version : float;
mutable features : (string,bool) Hashtbl.t;
mutable modules : Type.module_def list;
mutable main : Type.texpr option;
mutable types : Type.module_type list;
mutable resources : (string,string) Hashtbl.t;
mutable neko_libs : string list;
mutable php_front : string option;
mutable php_lib : string option;
mutable php_prefix : string option;
mutable swf_libs : (string * (unit -> Swf.swf) * (unit -> ((string list * string),As3hl.hl_class) Hashtbl.t)) list;
mutable java_libs : (string * bool * (unit -> unit) * (unit -> (path list)) * (path -> ((JData.jclass * string * string) option))) list; (* (path,std,close,all_files,lookup) *)
mutable net_libs : (string * bool * (unit -> path list) * (path -> IlData.ilclass option)) list; (* (path,std,all_files,lookup) *)
mutable net_std : string list;
net_path_map : (path,string list * string list * string) Hashtbl.t;
mutable c_args : string list;
mutable js_gen : (unit -> unit) option;
(* typing *)
mutable basic : basic_types;
memory_marker : float array;
}
exception Abort of string * Ast.pos
let display_default = ref DMNone
module Define = struct
type strict_defined =
| AbsolutePath
| AdvancedTelemetry
| Analyzer
| As3
| CheckXmlProxy
| CoreApi
| CoreApiSerialize
| Cppia
| Dce
| DceDebug
| Debug
| Display
| DllExport
| DllImport
| DocGen
| Dump
| DumpDependencies
| DumpIgnoreVarIds
| EraseGenerics
| Fdb
| FileExtension
| FlashStrict
| FlashUseStage
| ForceLibCheck
| ForceNativeProperty
| FormatWarning
| GencommonDebug
| HaxeBoot
| HaxeVer
| HxcppApiLevel
| IncludePrefix
| Interp
| JavaVer
| JsClassic
| JsEs5
| JsUnflatten
| KeepOldOutput
| LoopUnrollMaxCost
| Macro
| MacroTimes
| NekoSource
| NekoV1
| NetworkSandbox
| NetVer
| NetTarget
| NoCompilation
| NoCOpt
| NoDeprecationWarnings
| NoFlashOverride
| NoDebug
| NoInline
| NoOpt
| NoPatternMatching
| NoRoot
| NoSimplify
| NoSwfCompress
| NoTraces
| PhpPrefix
| RealPosition
| ReplaceFiles
| Scriptable
| ShallowExpose
| SourceMapContent
| Swc
| SwfCompressLevel
| SwfDebugPassword
| SwfDirectBlit
| SwfGpu
| SwfMetadata
| SwfPreloaderFrame
| SwfProtected
| SwfScriptTimeout
| SwfUseDoAbc
| Sys
| Unsafe
| UseNekoc
| UseRttiDoc
| Vcproj
| NoMacroCache
| Last (* must be last *)
let infos = function
| AbsolutePath -> ("absolute_path","Print absolute file path in trace output")
| AdvancedTelemetry -> ("advanced-telemetry","Allow the SWF to be measured with Monocle tool")
| Analyzer -> ("analyzer","Use static analyzer for optimization (experimental)")
| As3 -> ("as3","Defined when outputing flash9 as3 source code")
| CheckXmlProxy -> ("check_xml_proxy","Check the used fields of the xml proxy")
| CoreApi -> ("core_api","Defined in the core api context")
| CoreApiSerialize -> ("core_api_serialize","Sets so some generated core api classes be marked with the Serializable attribute on C#")
| Cppia -> ("cppia", "Generate experimental cpp instruction assembly")
| Dce -> ("dce","The current DCE mode")
| DceDebug -> ("dce_debug","Show DCE log")
| Debug -> ("debug","Activated when compiling with -debug")
| Display -> ("display","Activated during completion")
| DllExport -> ("dll_export", "GenCPP experimental linking")
| DllImport -> ("dll_import", "GenCPP experimental linking")
| DocGen -> ("doc_gen","Do not perform any removal/change in order to correctly generate documentation")
| Dump -> ("dump","Dump the complete typed AST for internal debugging")
| DumpDependencies -> ("dump_dependencies","Dump the classes dependencies")
| DumpIgnoreVarIds -> ("dump_ignore_var_ids","Dump files do not contain variable IDs (helps with diff)")
| EraseGenerics -> ("erase_generics","Erase generic classes on C#")
| Fdb -> ("fdb","Enable full flash debug infos for FDB interactive debugging")
| FileExtension -> ("file_extension","Output filename extension for cpp source code")
| FlashStrict -> ("flash_strict","More strict typing for flash target")
| FlashUseStage -> ("flash_use_stage","Keep the SWF library initial stage")
(* force_lib_check is only here as a debug facility - compiler checking allows errors to be found more easily *)
| ForceLibCheck -> ("force_lib_check","Force the compiler to check -net-lib and -java-lib added classes (internal)")
| ForceNativeProperty -> ("force_native_property","Tag all properties with :nativeProperty metadata for 3.1 compatibility")
| FormatWarning -> ("format_warning","Print a warning for each formated string, for 2.x compatibility")
| GencommonDebug -> ("gencommon_debug","GenCommon internal")
| HaxeBoot -> ("haxe_boot","Given the name 'haxe' to the flash boot class instead of a generated name")
| HaxeVer -> ("haxe_ver","The current Haxe version value")
| HxcppApiLevel -> ("hxcpp_api_level","Provided to allow compatibility between hxcpp versions")
| IncludePrefix -> ("include_prefix","prepend path to generated include files")
| Interp -> ("interp","The code is compiled to be run with --interp")
| JavaVer -> ("java_ver", " Sets the Java version to be targeted")
| JsClassic -> ("js_classic","Don't use a function wrapper and strict mode in JS output")
| JsEs5 -> ("js_es5","Generate JS for ES5-compliant runtimes")
| JsUnflatten -> ("js_unflatten","Generate nested objects for packages and types")
| KeepOldOutput -> ("keep_old_output","Keep old source files in the output directory (for C#/Java)")
| LoopUnrollMaxCost -> ("loop_unroll_max_cost","Maximum cost (number of expressions * iterations) before loop unrolling is canceled (default 250)")
| Macro -> ("macro","Defined when we compile code in the macro context")
| MacroTimes -> ("macro_times","Display per-macro timing when used with --times")
| NetVer -> ("net_ver", " Sets the .NET version to be targeted")
| NetTarget -> ("net_target", " Sets the .NET target. Defaults to \"net\". xbox, micro (Micro Framework), compact (Compact Framework) are some valid values")
| NekoSource -> ("neko_source","Output neko source instead of bytecode")
| NekoV1 -> ("neko_v1","Keep Neko 1.x compatibility")
| NetworkSandbox -> ("network-sandbox","Use local network sandbox instead of local file access one")
| NoCompilation -> ("no-compilation","Disable final compilation for Cs, Cpp and Java")
| NoCOpt -> ("no_copt","Disable completion optimization (for debug purposes)")
| NoDebug -> ("no_debug","Remove all debug macros from cpp output")
| NoDeprecationWarnings -> ("no-deprecation-warnings","Do not warn if fields annotated with @:deprecated are used")
| NoFlashOverride -> ("no-flash-override", "Change overrides on some basic classes into HX suffixed methods, flash only")
| NoOpt -> ("no_opt","Disable optimizations")
| NoPatternMatching -> ("no_pattern_matching","Disable pattern matching")
| NoInline -> ("no_inline","Disable inlining")
| NoRoot -> ("no_root","Generate top-level types into haxe.root namespace")
| NoMacroCache -> ("no_macro_cache","Disable macro context caching")
| NoSimplify -> "no_simplify",("Disable simplification filter")
| NoSwfCompress -> ("no_swf_compress","Disable SWF output compression")
| NoTraces -> ("no_traces","Disable all trace calls")
| PhpPrefix -> ("php_prefix","Compiled with --php-prefix")
| RealPosition -> ("real_position","Disables haxe source mapping when targetting C#")
| ReplaceFiles -> ("replace_files","GenCommon internal")
| Scriptable -> ("scriptable","GenCPP internal")
| ShallowExpose -> ("shallow-expose","Expose types to surrounding scope of Haxe generated closure without writing to window object")
| SourceMapContent -> ("source-map-content","Include the hx sources as part of the JS source map")
| Swc -> ("swc","Output a SWC instead of a SWF")
| SwfCompressLevel -> ("swf_compress_level"," Set the amount of compression for the SWF output")
| SwfDebugPassword -> ("swf_debug_password", "Set a password for debugging")
| SwfDirectBlit -> ("swf_direct_blit", "Use hardware acceleration to blit graphics")
| SwfGpu -> ("swf_gpu", "Use GPU compositing features when drawing graphics")
| SwfMetadata -> ("swf_metadata", "= Include contents of as metadata in the swf")
| SwfPreloaderFrame -> ("swf_preloader_frame", "Insert empty first frame in swf")
| SwfProtected -> ("swf_protected","Compile Haxe private as protected in the SWF instead of public")
| SwfScriptTimeout -> ("swf_script_timeout", "Maximum ActionScript processing time before script stuck dialog box displays (in seconds)")
| SwfUseDoAbc -> ("swf_use_doabc", "Use DoAbc swf-tag instead of DoAbcDefine")
| Sys -> ("sys","Defined for all system platforms")
| Unsafe -> ("unsafe","Allow unsafe code when targeting C#")
| UseNekoc -> ("use_nekoc","Use nekoc compiler instead of internal one")
| UseRttiDoc -> ("use_rtti_doc","Allows access to documentation during compilation")
| Vcproj -> ("vcproj","GenCPP internal")
| Last -> assert false
end
module MetaInfo = struct
open Meta
type meta_usage =
| TClass
| TClassField
| TAbstract
| TAbstractField
| TEnum
| TTypedef
| TAnyField
| TExpr
type meta_parameter =
| HasParam of string
| Platform of platform
| Platforms of platform list
| UsedOn of meta_usage
| UsedOnEither of meta_usage list
| Internal
let to_string = function
| Abi -> ":abi",("Function ABI/calling convention",[Platforms [Cpp]])
| Abstract -> ":abstract",("Sets the underlying class implementation as 'abstract'",[Platforms [Java;Cs]])
| Access -> ":access",("Forces private access to package, type or field",[HasParam "Target path";UsedOnEither [TClass;TClassField]])
| Accessor -> ":accessor",("Used internally by DCE to mark property accessors",[UsedOn TClassField;Internal])
| Allow -> ":allow",("Allows private access from package, type or field",[HasParam "Target path";UsedOnEither [TClass;TClassField]])
| Analyzer -> ":analyzer",("Used to configure the static analyzer",[])
| Annotation -> ":annotation",("Annotation (@interface) definitions on -java-lib imports will be annotated with this metadata. Has no effect on types compiled by Haxe",[Platform Java; UsedOn TClass])
| ArrayAccess -> ":arrayAccess",("Allows [] access on an abstract",[UsedOnEither [TAbstract;TAbstractField]])
| Ast -> ":ast",("Internally used to pass the AST source into the typed AST",[Internal])
| AutoBuild -> ":autoBuild",("Extends @:build metadata to all extending and implementing classes",[HasParam "Build macro call";UsedOn TClass])
| Bind -> ":bind",("Override Swf class declaration",[Platform Flash;UsedOn TClass])
| Bitmap -> ":bitmap",("Embeds given bitmap data into the class (must extend flash.display.BitmapData)",[HasParam "Bitmap file path";UsedOn TClass;Platform Flash])
| BridgeProperties -> ":bridgeProperties",("Creates native property bridges for all Haxe properties in this class",[UsedOn TClass;Platform Cs])
| Build -> ":build",("Builds a class or enum from a macro",[HasParam "Build macro call";UsedOnEither [TClass;TEnum]])
| BuildXml -> ":buildXml",("Specify xml data to be injected into Build.xml",[Platform Cpp])
| Callable -> ":callable",("Abstract forwards call to its underlying type",[UsedOn TAbstract])
| Class -> ":class",("Used internally to annotate an enum that will be generated as a class",[Platforms [Java;Cs]; UsedOn TEnum; Internal])
| ClassCode -> ":classCode",("Used to inject platform-native code into a class",[Platforms [Java;Cs]; UsedOn TClass])
| Commutative -> ":commutative",("Declares an abstract operator as commutative",[UsedOn TAbstractField])
| CompilerGenerated -> ":compilerGenerated",("Marks a field as generated by the compiler. Shouldn't be used by the end user",[Platforms [Java;Cs]])
| CoreApi -> ":coreApi",("Identifies this class as a core api class (forces Api check)",[UsedOnEither [TClass;TEnum;TTypedef;TAbstract]])
| CoreType -> ":coreType",("Identifies an abstract as core type so that it requires no implementation",[UsedOn TAbstract])
| CppFileCode -> ":cppFileCode",("Code to be injected into generated cpp file",[Platform Cpp])
| CppInclude -> ":cppInclude",("File to be included in generated cpp file",[Platform Cpp])
| CppNamespaceCode -> ":cppNamespaceCode",("",[Platform Cpp])
| CsNative -> ":csNative",("Automatically added by -net-lib on classes generated from .NET DLL files",[Platform Cs; UsedOnEither[TClass;TEnum]; Internal])
| Dce -> ":dce",("Forces dead code elimination even when -dce full is not specified",[UsedOnEither [TClass;TEnum]])
| Debug -> ":debug",("Forces debug information to be generated into the Swf even without -debug",[UsedOnEither [TClass;TClassField]; Platform Flash])
| Decl -> ":decl",("",[Platform Cpp])
| DefParam -> ":defParam",("?",[])
| Delegate -> ":delegate",("Automatically added by -net-lib on delegates",[Platform Cs; UsedOn TAbstract])
| Depend -> ":depend",("",[Platform Cpp])
| Deprecated -> ":deprecated",("Automatically added by -java-lib on class fields annotated with @Deprecated annotation. Has no effect on types compiled by Haxe",[Platform Java; UsedOnEither [TClass;TEnum;TClassField]])
| DirectlyUsed -> ":directlyUsed",("Marks types that are directly referenced by non-extern code",[Internal])
| DynamicObject -> ":dynamicObject",("Used internally to identify the Dynamic Object implementation",[Platforms [Java;Cs]; UsedOn TClass; Internal])
| Enum -> ":enum",("Used internally to annotate a class that was generated from an enum",[Platforms [Java;Cs]; UsedOn TClass; Internal])
| EnumConstructorParam -> ":enumConstructorParam",("Used internally to annotate GADT type parameters",[UsedOn TClass; Internal])
| Event -> ":event",("Automatically added by -net-lib on events. Has no effect on types compiled by Haxe",[Platform Cs; UsedOn TClassField])
| Exhaustive -> ":exhaustive",("",[Internal])
| Expose -> ":expose",("Makes the class available on the window object",[HasParam "?Name=Class path";UsedOn TClass;Platform Js])
| Extern -> ":extern",("Marks the field as extern so it is not generated",[UsedOn TClassField])
| FakeEnum -> ":fakeEnum",("Treat enum as collection of values of the specified type",[HasParam "Type name";UsedOn TEnum])
| File -> ":file",("Includes a given binary file into the target Swf and associates it with the class (must extend flash.utils.ByteArray)",[HasParam "File path";UsedOn TClass;Platform Flash])
| Final -> ":final",("Prevents a class from being extended",[UsedOn TClass])
| FlatEnum -> ":flatEnum",("Internally used to mark an enum as being flat, i.e. having no function constructors",[UsedOn TEnum; Internal])
| Font -> ":font",("Embeds the given TrueType font into the class (must extend flash.text.Font)",[HasParam "TTF path";HasParam "Range String";UsedOn TClass])
| Forward -> ":forward",("Forwards field access to underlying type",[HasParam "List of field names";UsedOn TAbstract])
| From -> ":from",("Specifies that the field of the abstract is a cast operation from the type identified in the function",[UsedOn TAbstractField])
| FunctionCode -> ":functionCode",("",[Platform Cpp])
| FunctionTailCode -> ":functionTailCode",("",[Platform Cpp])
| Generic -> ":generic",("Marks a class or class field as generic so each type parameter combination generates its own type/field",[UsedOnEither [TClass;TClassField]])
| GenericBuild -> ":genericBuild",("Builds instances of a type using the specified macro",[UsedOn TClass])
| GenericInstance -> ":genericInstance",("Internally used to mark instances of @:generic methods",[UsedOn TClassField;Internal])
| Getter -> ":getter",("Generates a native getter function on the given field",[HasParam "Class field name";UsedOn TClassField;Platform Flash])
| Hack -> ":hack",("Allows extending classes marked as @:final",[UsedOn TClass])
| HasUntyped -> (":has_untyped",("Used by the typer to mark fields that have untyped expressions",[Internal]))
| HaxeGeneric -> ":haxeGeneric",("Used internally to annotate non-native generic classes",[Platform Cs; UsedOnEither[TClass;TEnum]; Internal])
| HeaderClassCode -> ":headerClassCode",("Code to be injected into the generated class, in the header",[Platform Cpp])
| HeaderCode -> ":headerCode",("Code to be injected into the generated header file",[Platform Cpp])
| HeaderInclude -> ":headerInclude",("File to be included in generated header file",[Platform Cpp])
| HeaderNamespaceCode -> ":headerNamespaceCode",("",[Platform Cpp])
| HxGen -> ":hxGen",("Annotates that an extern class was generated by Haxe",[Platforms [Java;Cs]; UsedOnEither [TClass;TEnum]])
| IfFeature -> ":ifFeature",("Causes a field to be kept by DCE if the given feature is part of the compilation",[HasParam "Feature name";UsedOn TClassField])
| Impl -> ":impl",("Used internally to mark abstract implementation fields",[UsedOn TAbstractField; Internal])
| PythonImport -> ":pythonImport",("Generates python import statement for extern classes",[Platforms [Python]; UsedOn TClass])
| ImplicitCast -> ":implicitCast",("Generated automatically on the AST when an implicit abstract cast happens",[Internal; UsedOn TExpr])
| Include -> ":include",("",[Platform Cpp])
| InitPackage -> ":initPackage",("?",[])
| Meta.Internal -> ":internal",("Generates the annotated field/class with 'internal' access",[Platforms [Java;Cs]; UsedOnEither[TClass;TEnum;TClassField]])
| IsVar -> ":isVar",("Forces a physical field to be generated for properties that otherwise would not require one",[UsedOn TClassField])
| JavaCanonical -> ":javaCanonical",("Used by the Java target to annotate the canonical path of the type",[HasParam "Output type package";HasParam "Output type name";UsedOnEither [TClass;TEnum]; Platform Java])
| JavaNative -> ":javaNative",("Automatically added by -java-lib on classes generated from JAR/class files",[Platform Java; UsedOnEither[TClass;TEnum]; Internal])
| JsRequire -> ":jsRequire",("Generate javascript module require expression for given extern",[Platform Js; UsedOn TClass])
| Keep -> ":keep",("Causes a field or type to be kept by DCE",[])
| KeepInit -> ":keepInit",("Causes a class to be kept by DCE even if all its field are removed",[UsedOn TClass])
| KeepSub -> ":keepSub",("Extends @:keep metadata to all implementing and extending classes",[UsedOn TClass])
| LibType -> ":libType",("Used by -net-lib and -java-lib to mark a class that shouldn't be checked (overrides, interfaces, etc) by the type loader",[Internal; UsedOn TClass; Platforms [Java;Cs]])
| Meta -> ":meta",("Internally used to mark a class field as being the metadata field",[])
| Macro -> ":macro",("(deprecated)",[])
| MaybeUsed -> ":maybeUsed",("Internally used by DCE to mark fields that might be kept",[Internal])
| MergeBlock -> ":mergeBlock",("Merge the annotated block into the current scope",[UsedOn TExpr])
| MultiType -> ":multiType",("Specifies that an abstract chooses its this-type from its @:to functions",[UsedOn TAbstract; HasParam "Relevant type parameters"])
| Native -> ":native",("Rewrites the path of a class or enum during generation",[HasParam "Output type path";UsedOnEither [TClass;TEnum]])
| NativeChildren -> ":nativeChildren",("Annotates that all children from a type should be treated as if it were an extern definition - platform native",[Platforms [Java;Cs]; UsedOn TClass])
| NativeGen -> ":nativeGen",("Annotates that a type should be treated as if it were an extern definition - platform native",[Platforms [Java;Cs;Python]; UsedOnEither[TClass;TEnum]])
| NativeGeneric -> ":nativeGeneric",("Used internally to annotate native generic classes",[Platform Cs; UsedOnEither[TClass;TEnum]; Internal])
| NativeProperty -> ":nativeProperty",("Use native properties which will execute even with dynamic usage",[Platform Cpp])
| NoCompletion -> ":noCompletion",("Prevents the compiler from suggesting completion on this field",[UsedOn TClassField])
| NoDebug -> ":noDebug",("Does not generate debug information into the Swf even if -debug is set",[UsedOnEither [TClass;TClassField];Platform Flash])
| NoDoc -> ":noDoc",("Prevents a type from being included in documentation generation",[])
| NoExpr -> ":noExpr",("Internally used to mark abstract fields which have no expression by design",[Internal])
| NoImportGlobal -> ":noImportGlobal",("Prevents a static field from being imported with import Class.*",[UsedOn TAnyField])
| NonVirtual -> ":nonVirtual",("Declares function to be non-virtual in cpp",[Platform Cpp])
| NoPackageRestrict -> ":noPackageRestrict",("Allows a module to be accessed across all targets if found on its first type",[Internal])
| NoPrivateAccess -> ":noPrivateAccess",("Disallow private access to anything for the annotated expression",[UsedOn TExpr])
| NoStack -> ":noStack",("",[Platform Cpp])
| NotNull -> ":notNull",("Declares an abstract type as not accepting null values",[UsedOn TAbstract])
| NoUsing -> ":noUsing",("Prevents a field from being used with 'using'",[UsedOn TClassField])
| Ns -> ":ns",("Internally used by the Swf generator to handle namespaces",[Platform Flash])
| Op -> ":op",("Declares an abstract field as being an operator overload",[HasParam "The operation";UsedOn TAbstractField])
| Optional -> ":optional",("Marks the field of a structure as optional",[UsedOn TClassField])
| Overload -> ":overload",("Allows the field to be called with different argument types",[HasParam "Function specification (no expression)";UsedOn TClassField])
| Public -> ":public",("Marks a class field as being public",[UsedOn TClassField])
| PublicFields -> ":publicFields",("Forces all class fields of inheriting classes to be public",[UsedOn TClass])
| QuotedField -> ":quotedField",("Used internally to mark structure fields which are quoted in syntax",[Internal])
| PrivateAccess -> ":privateAccess",("Allow private access to anything for the annotated expression",[UsedOn TExpr])
| Protected -> ":protected",("Marks a class field as being protected",[UsedOn TClassField])
| Property -> ":property",("Marks a property field to be compiled as a native C# property",[UsedOn TClassField;Platform Cs])
| ReadOnly -> ":readOnly",("Generates a field with the 'readonly' native keyword",[Platform Cs; UsedOn TClassField])
| RealPath -> ":realPath",("Internally used on @:native types to retain original path information",[Internal])
| Remove -> ":remove",("Causes an interface to be removed from all implementing classes before generation",[UsedOn TClass])
| Require -> ":require",("Allows access to a field only if the specified compiler flag is set",[HasParam "Compiler flag to check";UsedOn TClassField])
| RequiresAssign -> ":requiresAssign",("Used internally to mark certain abstract operator overloads",[Internal])
(* | Resolve -> ":resolve",("Abstract fields marked with this metadata can be used to resolve unknown fields",[UsedOn TClassField]) *)
| ReplaceReflection -> ":replaceReflection",("Used internally to specify a function that should replace its internal __hx_functionName counterpart",[Platforms [Java;Cs]; UsedOnEither[TClass;TEnum]; Internal])
| Rtti -> ":rtti",("Adds runtime type informations",[UsedOn TClass])
| Runtime -> ":runtime",("?",[])
| RuntimeValue -> ":runtimeValue",("Marks an abstract as being a runtime value",[UsedOn TAbstract])
| SelfCall -> ":selfCall",("Translates method calls into calling object directly",[UsedOn TClassField; Platform Js])
| Setter -> ":setter",("Generates a native setter function on the given field",[HasParam "Class field name";UsedOn TClassField;Platform Flash])
| StoredTypedExpr -> ":storedTypedExpr",("Used internally to reference a typed expression returned from a macro",[Internal])
| SkipCtor -> ":skipCtor",("Used internally to generate a constructor as if it were a native type (no __hx_ctor)",[Platforms [Java;Cs]; Internal])
| SkipReflection -> ":skipReflection",("Used internally to annotate a field that shouldn't have its reflection data generated",[Platforms [Java;Cs]; UsedOn TClassField; Internal])
| Sound -> ":sound",( "Includes a given .wav or .mp3 file into the target Swf and associates it with the class (must extend flash.media.Sound)",[HasParam "File path";UsedOn TClass;Platform Flash])
| SourceFile -> ":sourceFile",("Source code filename for external class",[Platform Cpp])
| Strict -> ":strict",("Used to declare a native C# attribute or a native Java metadata. Is type checked",[Platforms [Java;Cs]])
| Struct -> ":struct",("Marks a class definition as a struct",[Platform Cs; UsedOn TClass])
| StructAccess -> ":structAccess",("Marks an extern class as using struct access('.') not pointer('->')",[Platform Cpp; UsedOn TClass])
| SuppressWarnings -> ":suppressWarnings",("Adds a SuppressWarnings annotation for the generated Java class",[Platform Java; UsedOn TClass])
| Throws -> ":throws",("Adds a 'throws' declaration to the generated function",[HasParam "Type as String"; Platform Java; UsedOn TClassField])
| This -> ":this",("Internally used to pass a 'this' expression to macros",[Internal; UsedOn TExpr])
| To -> ":to",("Specifies that the field of the abstract is a cast operation to the type identified in the function",[UsedOn TAbstractField])
| ToString -> ":toString",("Internally used",[Internal])
| Transient -> ":transient",("Adds the 'transient' flag to the class field",[Platform Java; UsedOn TClassField])
| ValueUsed -> ":valueUsed",("Internally used by DCE to mark an abstract value as used",[Internal])
| Volatile -> ":volatile",("",[Platforms [Java;Cs]])
| Unbound -> ":unbound", ("Compiler internal to denote unbounded global variable",[])
| UnifyMinDynamic -> ":unifyMinDynamic",("Allows a collection of types to unify to Dynamic",[UsedOn TClassField])
| Unreflective -> ":unreflective",("",[Platform Cpp])
| Unsafe -> ":unsafe",("Declares a class, or a method with the C#'s 'unsafe' flag",[Platform Cs; UsedOnEither [TClass;TClassField]])
| Usage -> ":usage",("?",[])
| Used -> ":used",("Internally used by DCE to mark a class or field as used",[Internal])
| Value -> ":value",("Used to store default values for fields and function arguments",[UsedOn TClassField])
| Void -> ":void",("Use Cpp native 'void' return type",[Platform Cpp])
| Last -> assert false
(* do not put any custom metadata after Last *)
| Dollar s -> "$" ^ s,("",[])
| Custom s -> s,("",[])
let hmeta =
let h = Hashtbl.create 0 in
let rec loop i =
let m = Obj.magic i in
if m <> Last then begin
Hashtbl.add h (fst (to_string m)) m;
loop (i + 1);
end;
in
loop 0;
h
let parse s = try Hashtbl.find hmeta (":" ^ s) with Not_found -> Custom (":" ^ s)
let from_string s =
if s = "" then Custom "" else match s.[0] with
| ':' -> (try Hashtbl.find hmeta s with Not_found -> Custom s)
| '$' -> Dollar (String.sub s 1 (String.length s - 1))
| _ -> Custom s
end
let stats =
{
s_files_parsed = ref 0;
s_classes_built = ref 0;
s_methods_typed = ref 0;
s_macros_called = ref 0;
}
let default_config =
{
pf_static = true;
pf_sys = true;
pf_locals_scope = true;
pf_captured_scope = true;
pf_unique_locals = false;
pf_capture_policy = CPNone;
pf_pad_nulls = false;
pf_add_final_return = false;
pf_overload = false;
pf_pattern_matching = false;
pf_can_skip_non_nullable_argument = true;
pf_reserved_type_paths = [];
}
let get_config com =
let defined f = PMap.mem (fst (Define.infos f)) com.defines in
match com.platform with
| Cross ->
default_config
| Js ->
{
pf_static = false;
pf_sys = false;
pf_locals_scope = false;
pf_captured_scope = false;
pf_unique_locals = false;
pf_capture_policy = CPLoopVars;
pf_pad_nulls = false;
pf_add_final_return = false;
pf_overload = false;
pf_pattern_matching = false;
pf_can_skip_non_nullable_argument = true;
pf_reserved_type_paths = [([],"Object");([],"Error")];
}
| Neko ->
{
pf_static = false;
pf_sys = true;
pf_locals_scope = true;
pf_captured_scope = true;
pf_unique_locals = false;
pf_capture_policy = CPNone;
pf_pad_nulls = true;
pf_add_final_return = false;
pf_overload = false;
pf_pattern_matching = false;
pf_can_skip_non_nullable_argument = true;
pf_reserved_type_paths = [];
}
| Flash when defined Define.As3 ->
{
pf_static = true;
pf_sys = false;
pf_locals_scope = false;
pf_captured_scope = true;
pf_unique_locals = true;
pf_capture_policy = CPLoopVars;
pf_pad_nulls = false;
pf_add_final_return = true;
pf_overload = false;
pf_pattern_matching = false;
pf_can_skip_non_nullable_argument = false;
pf_reserved_type_paths = [];
}
| Flash ->
{
pf_static = true;
pf_sys = false;
pf_locals_scope = true;
pf_captured_scope = true; (* handled by genSwf9 *)
pf_unique_locals = false;
pf_capture_policy = CPLoopVars;
pf_pad_nulls = false;
pf_add_final_return = false;
pf_overload = false;
pf_pattern_matching = false;
pf_can_skip_non_nullable_argument = false;
pf_reserved_type_paths = [([],"Object");([],"Error")];
}
| Php ->
{
pf_static = false;
pf_sys = true;
pf_locals_scope = false; (* some duplicate work is done in genPhp *)
pf_captured_scope = false;
pf_unique_locals = false;
pf_capture_policy = CPNone;
pf_pad_nulls = true;
pf_add_final_return = false;
pf_overload = false;
pf_pattern_matching = false;
pf_can_skip_non_nullable_argument = true;
pf_reserved_type_paths = [];
}
| Cpp ->
{
pf_static = true;
pf_sys = true;
pf_locals_scope = true;
pf_captured_scope = true;
pf_unique_locals = false;
pf_capture_policy = CPWrapRef;
pf_pad_nulls = true;
pf_add_final_return = true;
pf_overload = false;
pf_pattern_matching = false;
pf_can_skip_non_nullable_argument = true;
pf_reserved_type_paths = [];
}
| Cs ->
{
pf_static = true;
pf_sys = true;
pf_locals_scope = false;
pf_captured_scope = true;
pf_unique_locals = true;
pf_capture_policy = CPWrapRef;
pf_pad_nulls = true;
pf_add_final_return = false;
pf_overload = true;
pf_pattern_matching = false;
pf_can_skip_non_nullable_argument = true;
pf_reserved_type_paths = [];
}
| Java ->
{
pf_static = true;
pf_sys = true;
pf_locals_scope = false;
pf_captured_scope = true;
pf_unique_locals = false;
pf_capture_policy = CPWrapRef;
pf_pad_nulls = true;
pf_add_final_return = false;
pf_overload = true;
pf_pattern_matching = false;
pf_can_skip_non_nullable_argument = true;
pf_reserved_type_paths = [];
}
| Python ->
{
pf_static = false;
pf_sys = true;
pf_locals_scope = false;
pf_captured_scope = false;
pf_unique_locals = false;
pf_capture_policy = CPLoopVars;
pf_pad_nulls = false;
pf_add_final_return = false;
pf_overload = false;
pf_pattern_matching = false;
pf_can_skip_non_nullable_argument = true;
pf_reserved_type_paths = [];
}
let memory_marker = [|Unix.time()|]
let create v args =
let m = Type.mk_mono() in
{
version = v;
args = args;
sys_args = args;
debug = false;
display = !display_default;
verbose = false;
foptimize = true;
features = Hashtbl.create 0;
platform = Cross;
config = default_config;
print = (fun s -> print_string s; flush stdout);
run_command = Sys.command;
std_path = [];
class_path = [];
main_class = None;
defines = PMap.add "true" "1" (if !display_default <> DMNone then PMap.add "display" "1" PMap.empty else PMap.empty);
package_rules = PMap.empty;
file = "";
types = [];
filters = [];
final_filters = [];
modules = [];
main = None;
flash_version = 10.;
resources = Hashtbl.create 0;
php_front = None;
php_lib = None;
swf_libs = [];
java_libs = [];
net_libs = [];
net_std = [];
net_path_map = Hashtbl.create 0;
c_args = [];
neko_libs = [];
php_prefix = None;
js_gen = None;
load_extern_type = [];
defines_signature = None;
get_macros = (fun() -> None);
warning = (fun _ _ -> assert false);
error = (fun _ _ -> assert false);
basic = {
tvoid = m;
tint = m;
tfloat = m;
tbool = m;
tnull = (fun _ -> assert false);
tstring = m;
tarray = (fun _ -> assert false);
};
file_lookup_cache = Hashtbl.create 0;
stored_typed_exprs = PMap.empty;
memory_marker = memory_marker;
}
let log com str =
if com.verbose then com.print (str ^ "\n")
let clone com =
let t = com.basic in
{ com with
basic = { t with tvoid = t.tvoid };
main_class = None;
features = Hashtbl.create 0;
file_lookup_cache = Hashtbl.create 0;
}
let file_time file =
try (Unix.stat file).Unix.st_mtime with _ -> 0.
let get_signature com =
match com.defines_signature with
| Some s -> s
| None ->
let str = String.concat "@" (PMap.foldi (fun k v acc ->
(* don't make much difference between these special compilation flags *)
match k with
| "display" | "use_rtti_doc" | "macrotimes" -> acc
| _ -> k :: v :: acc
) com.defines []) in
let s = Digest.string str in
com.defines_signature <- Some s;
s
let file_extension file =
match List.rev (ExtString.String.nsplit file ".") with
| e :: _ -> String.lowercase e
| [] -> ""
let platforms = [
Js;
Neko;
Flash;
Php;
Cpp;
Cs;
Java;
Python;
]
let platform_name = function
| Cross -> "cross"
| Js -> "js"
| Neko -> "neko"
| Flash -> "flash"
| Php -> "php"
| Cpp -> "cpp"
| Cs -> "cs"
| Java -> "java"
| Python -> "python"
let flash_versions = List.map (fun v ->
let maj = int_of_float v in
let min = int_of_float (mod_float (v *. 10.) 10.) in
v, string_of_int maj ^ (if min = 0 then "" else "_" ^ string_of_int min)
) [9.;10.;10.1;10.2;10.3;11.;11.1;11.2;11.3;11.4;11.5;11.6;11.7;11.8;11.9;12.0;13.0;14.0;15.0;16.0;17.0]
let flash_version_tag = function
| 6. -> 6
| 7. -> 7
| 8. -> 8
| 9. -> 9
| 10. | 10.1 -> 10
| 10.2 -> 11
| 10.3 -> 12
| 11. -> 13
| 11.1 -> 14
| 11.2 -> 15
| 11.3 -> 16
| 11.4 -> 17
| 11.5 -> 18
| 11.6 -> 19
| 11.7 -> 20
| 11.8 -> 21
| 11.9 -> 22
| 12.0 -> 23
| 13.0 -> 24
| 14.0 -> 25
| 15.0 -> 26
| 16.0 -> 27
| 17.0 -> 28
| v -> failwith ("Invalid SWF version " ^ string_of_float v)
let raw_defined ctx v =
PMap.mem v ctx.defines
let defined ctx v =
raw_defined ctx (fst (Define.infos v))
let raw_defined_value ctx k =
PMap.find k ctx.defines
let defined_value ctx v =
raw_defined_value ctx (fst (Define.infos v))
let defined_value_safe ctx v =
try defined_value ctx v
with Not_found -> ""
let raw_define ctx v =
let k,v = try ExtString.String.split v "=" with _ -> v,"1" in
ctx.defines <- PMap.add k v ctx.defines;
let k = String.concat "_" (ExtString.String.nsplit k "-") in
ctx.defines <- PMap.add k v ctx.defines;
ctx.defines_signature <- None
let define_value ctx k v =
raw_define ctx (fst (Define.infos k) ^ "=" ^ v)
let define ctx v =
raw_define ctx (fst (Define.infos v))
let init_platform com pf =
com.platform <- pf;
let name = platform_name pf in
let forbid acc p = if p = name || PMap.mem p acc then acc else PMap.add p Forbidden acc in
com.package_rules <- List.fold_left forbid com.package_rules (List.map platform_name platforms);
com.config <- get_config com;
(* if com.config.pf_static then define com "static"; *)
if com.config.pf_sys then define com Define.Sys else com.package_rules <- PMap.add "sys" Forbidden com.package_rules;
raw_define com name
let add_feature com f =
Hashtbl.replace com.features f true
let has_dce com =
(try defined_value com Define.Dce <> "no" with Not_found -> false)
(*
TODO: The has_dce check is there because we mark types with @:directlyUsed in the DCE filter,
which is not run in dce=no and thus we can't know if a type is used directly or not,
so we just assume that they are.
If we had dce filter always running (even with dce=no), we would have types marked with @:directlyUsed
and we wouldn't need to generate unnecessary imports in dce=no, but that's good enough for now.
*)
let is_directly_used com meta =
not (has_dce com) || Ast.Meta.has Ast.Meta.DirectlyUsed meta
let rec has_feature com f =
try
Hashtbl.find com.features f
with Not_found ->
if com.types = [] then not (has_dce com) else
match List.rev (ExtString.String.nsplit f ".") with
| [] -> assert false
| [cl] -> has_feature com (cl ^ ".*")
| meth :: cl :: pack ->
let r = (try
let path = List.rev pack, cl in
(match List.find (fun t -> t_path t = path && not (Ast.Meta.has Ast.Meta.RealPath (t_infos t).mt_meta)) com.types with
| t when meth = "*" -> (match t with TAbstractDecl a -> Ast.Meta.has Ast.Meta.ValueUsed a.a_meta | _ ->
Ast.Meta.has Ast.Meta.Used (t_infos t).mt_meta)
| TClassDecl ({cl_extern = true} as c) when com.platform <> Js || cl <> "Array" && cl <> "Math" ->
Meta.has Meta.Used (try PMap.find meth c.cl_statics with Not_found -> PMap.find meth c.cl_fields).cf_meta
| TClassDecl c ->
PMap.exists meth c.cl_statics || PMap.exists meth c.cl_fields
| _ ->
false)
with Not_found ->
false
) in
let r = r || not (has_dce com) in
Hashtbl.add com.features f r;
r
let allow_package ctx s =
try
if (PMap.find s ctx.package_rules) = Forbidden then ctx.package_rules <- PMap.remove s ctx.package_rules
with Not_found ->
()
let error msg p = raise (Abort (msg,p))
let platform ctx p = ctx.platform = p
let add_filter ctx f =
ctx.filters <- f :: ctx.filters
let add_final_filter ctx f =
ctx.final_filters <- f :: ctx.final_filters
let find_file ctx f =
try
(match Hashtbl.find ctx.file_lookup_cache f with
| None -> raise Exit
| Some f -> f)
with Exit ->
raise Not_found
| Not_found ->
let rec loop had_empty = function
| [] when had_empty -> raise Not_found
| [] -> loop true [""]
| p :: l ->
let file = p ^ f in
if Sys.file_exists file then
file
else
loop (had_empty || p = "") l
in
let r = (try Some (loop false ctx.class_path) with Not_found -> None) in
Hashtbl.add ctx.file_lookup_cache f r;
(match r with
| None -> raise Not_found
| Some f -> f)
let get_full_path f = try Extc.get_full_path f with _ -> f
let unique_full_path = if Sys.os_type = "Win32" || Sys.os_type = "Cygwin" then (fun f -> String.lowercase (get_full_path f)) else get_full_path
let normalize_path p =
let l = String.length p in
if l = 0 then
"./"
else match p.[l-1] with
| '\\' | '/' -> p
| _ -> p ^ "/"
let rec mkdir_recursive base dir_list =
match dir_list with
| [] -> ()
| dir :: remaining ->
let path = match base with
| "" -> dir
| "/" -> "/" ^ dir
| _ -> base ^ "/" ^ dir
in
if not ( (path = "") || ( ((String.length path) = 2) && ((String.sub path 1 1) = ":") ) ) then
if not (Sys.file_exists path) then
Unix.mkdir path 0o755;
mkdir_recursive (if (path = "") then "/" else path) remaining
let mkdir_from_path path =
let parts = Str.split_delim (Str.regexp "[\\/]+") path in
match parts with
| [] -> (* path was "" *) ()
| _ ->
let dir_list = List.rev (List.tl (List.rev parts)) in
mkdir_recursive "" dir_list
let mem_size v =
Objsize.size_with_headers (Objsize.objsize v [] [])
(* ------------------------- TIMERS ----------------------------- *)
type timer_infos = {
name : string;
mutable start : float list;
mutable total : float;
}
let get_time = Extc.time
let htimers = Hashtbl.create 0
let new_timer name =
try
let t = Hashtbl.find htimers name in
t.start <- get_time() :: t.start;
t
with Not_found ->
let t = { name = name; start = [get_time()]; total = 0.; } in
Hashtbl.add htimers name t;
t
let curtime = ref []
let close t =
let start = (match t.start with
| [] -> assert false
| s :: l -> t.start <- l; s
) in
let now = get_time() in
let dt = now -. start in
t.total <- t.total +. dt;
let rec loop() =
match !curtime with
| [] -> failwith ("Timer " ^ t.name ^ " closed while not active")
| tt :: l -> curtime := l; if t != tt then loop()
in
loop();
(* because of rounding errors while adding small times, we need to make sure that we don't have start > now *)
List.iter (fun ct -> ct.start <- List.map (fun t -> let s = t +. dt in if s > now then now else s) ct.start) !curtime
let timer name =
let t = new_timer name in
curtime := t :: !curtime;
(function() -> close t)
let rec close_times() =
match !curtime with
| [] -> ()
| t :: _ -> close t; close_times()
;;
Ast.Meta.to_string_ref := fun m -> fst (MetaInfo.to_string m)
(* Taken from OCaml source typing/oprint.ml
This is a better version of string_of_float which prints without loss of precision
so that float_of_string (float_repres x) = x for all floats x
*)
let valid_float_lexeme s =
let l = String.length s in
let rec loop i =
if i >= l then s ^ "." else
match s.[i] with
| '0' .. '9' | '-' -> loop (i+1)
| _ -> s
in loop 0
let float_repres f =
match classify_float f with
| FP_nan -> "nan"
| FP_infinite ->
if f < 0.0 then "neg_infinity" else "infinity"
| _ ->
let float_val =
let s1 = Printf.sprintf "%.12g" f in
if f = float_of_string s1 then s1 else
let s2 = Printf.sprintf "%.15g" f in
if f = float_of_string s2 then s2 else
Printf.sprintf "%.18g" f
in valid_float_lexeme float_val
haxe_3.2.1+dfsg.orig/dce.ml 0000664 0001750 0001750 00000060103 12607337712 015411 0 ustar andy andy 0000000 0000000 (*
* Copyright (C)2005-2013 Haxe Foundation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*)
open Ast
open Common
open Type
type dce = {
com : context;
full : bool;
std_dirs : string list;
debug : bool;
follow_expr : dce -> texpr -> unit;
mutable curclass : tclass;
mutable added_fields : (tclass * tclass_field * bool) list;
mutable marked_fields : tclass_field list;
mutable marked_maybe_fields : tclass_field list;
mutable t_stack : t list;
mutable ts_stack : t list;
mutable features : (string,(tclass * tclass_field * bool) list) Hashtbl.t;
}
(* checking *)
(* check for @:keepSub metadata, which forces @:keep on child classes *)
let rec super_forces_keep c =
Meta.has Meta.KeepSub c.cl_meta || match c.cl_super with
| Some (csup,_) -> super_forces_keep csup
| _ -> false
let is_std_file dce file =
List.exists (ExtString.String.starts_with file) dce.std_dirs
(* check if a class is kept entirely *)
let keep_whole_class dce c =
Meta.has Meta.Keep c.cl_meta
|| not (dce.full || is_std_file dce c.cl_module.m_extra.m_file || has_meta Meta.Dce c.cl_meta)
|| super_forces_keep c
|| (match c with
| { cl_path = ([],("Math"|"Array"))} when dce.com.platform = Js -> false
| { cl_extern = true }
| { cl_path = ["flash";"_Boot"],"RealBoot" } -> true
| { cl_path = [],"String" }
| { cl_path = [],"Array" } -> not (dce.com.platform = Js)
| _ -> false)
let keep_whole_enum dce en =
Meta.has Meta.Keep en.e_meta
|| not (dce.full || is_std_file dce en.e_module.m_extra.m_file || has_meta Meta.Dce en.e_meta)
(* check if a field is kept *)
let keep_field dce cf =
Meta.has Meta.Keep cf.cf_meta
|| Meta.has Meta.Used cf.cf_meta
|| cf.cf_name = "__init__"
|| is_extern_field cf
(* marking *)
let rec check_feature dce s =
try
let l = Hashtbl.find dce.features s in
List.iter (fun (c,cf,stat) ->
mark_field dce c cf stat
) l;
Hashtbl.remove dce.features s;
with Not_found ->
()
and check_and_add_feature dce s =
check_feature dce s;
Common.add_feature dce.com s;
(* mark a field as kept *)
and mark_field dce c cf stat =
let add cf =
if not (Meta.has Meta.Used cf.cf_meta) then begin
cf.cf_meta <- (Meta.Used,[],cf.cf_pos) :: cf.cf_meta;
dce.added_fields <- (c,cf,stat) :: dce.added_fields;
dce.marked_fields <- cf :: dce.marked_fields;
check_feature dce (Printf.sprintf "%s.%s" (s_type_path c.cl_path) cf.cf_name);
end
in
if cf.cf_name = "new" then begin
let rec loop c = match c.cl_super with
| None -> ()
| Some (csup,_) ->
begin match csup.cl_constructor with
| None -> ()
| Some cf -> add cf
end;
loop csup
in
loop c
end;
if not (PMap.mem cf.cf_name (if stat then c.cl_statics else c.cl_fields)) then begin
match c.cl_super with
| None -> add cf
| Some (c,_) -> mark_field dce c cf stat
end else
add cf
let rec update_marked_class_fields dce c =
(* mark all :?used fields as surely :used now *)
List.iter (fun cf ->
if Meta.has Meta.MaybeUsed cf.cf_meta then mark_field dce c cf true
) c.cl_ordered_statics;
List.iter (fun cf ->
if Meta.has Meta.MaybeUsed cf.cf_meta then mark_field dce c cf false
) c.cl_ordered_fields;
(* we always have to keep super classes and implemented interfaces *)
(match c.cl_init with None -> () | Some init -> dce.follow_expr dce init);
List.iter (fun (c,_) -> mark_class dce c) c.cl_implements;
(match c.cl_super with None -> () | Some (csup,pl) -> mark_class dce csup)
(* mark a class as kept. If the class has fields marked as @:?keep, make sure to keep them *)
and mark_class dce c = if not (Meta.has Meta.Used c.cl_meta) then begin
c.cl_meta <- (Meta.Used,[],c.cl_pos) :: c.cl_meta;
check_feature dce (Printf.sprintf "%s.*" (s_type_path c.cl_path));
update_marked_class_fields dce c;
end
let rec mark_enum dce e = if not (Meta.has Meta.Used e.e_meta) then begin
e.e_meta <- (Meta.Used,[],e.e_pos) :: e.e_meta;
check_and_add_feature dce "has_enum";
check_feature dce (Printf.sprintf "%s.*" (s_type_path e.e_path));
PMap.iter (fun _ ef -> mark_t dce ef.ef_pos ef.ef_type) e.e_constrs;
end
and mark_abstract dce a = if not (Meta.has Meta.Used a.a_meta) then begin
check_feature dce (Printf.sprintf "%s.*" (s_type_path a.a_path));
a.a_meta <- (Meta.Used,[],a.a_pos) :: a.a_meta
end
(* mark a type as kept *)
and mark_t dce p t =
if not (List.exists (fun t2 -> Type.fast_eq t t2) dce.t_stack) then begin
dce.t_stack <- t :: dce.t_stack;
begin match follow t with
| TInst({cl_kind = KTypeParameter tl} as c,pl) ->
if not (Meta.has Meta.Used c.cl_meta) then begin
c.cl_meta <- (Meta.Used,[],c.cl_pos) :: c.cl_meta;
List.iter (mark_t dce p) tl;
end;
List.iter (mark_t dce p) pl
| TInst(c,pl) ->
mark_class dce c;
List.iter (mark_t dce p) pl
| TFun(args,ret) ->
List.iter (fun (_,_,t) -> mark_t dce p t) args;
mark_t dce p ret
| TEnum(e,pl) ->
mark_enum dce e;
List.iter (mark_t dce p) pl
| TAbstract(a,pl) when Meta.has Meta.MultiType a.a_meta ->
begin try
mark_t dce p (snd (Codegen.AbstractCast.find_multitype_specialization dce.com a pl p))
with Typecore.Error _ ->
()
end
| TAbstract(a,pl) ->
mark_abstract dce a;
List.iter (mark_t dce p) pl;
if not (Meta.has Meta.CoreType a.a_meta) then
mark_t dce p (Abstract.get_underlying_type a pl)
| TLazy _ | TDynamic _ | TType _ | TAnon _ | TMono _ -> ()
end;
dce.t_stack <- List.tl dce.t_stack
end
let mark_mt dce mt = match mt with
| TClassDecl c ->
mark_class dce c;
| TEnumDecl e ->
mark_enum dce e
| TAbstractDecl a ->
(* abstract 'feature' is defined as the abstract type beeing used as a value, not as a type *)
if not (Meta.has Meta.ValueUsed a.a_meta) then a.a_meta <- (Meta.ValueUsed,[],a.a_pos) :: a.a_meta;
mark_abstract dce a
| TTypeDecl _ ->
()
(* find all dependent fields by checking implementing/subclassing types *)
let rec mark_dependent_fields dce csup n stat =
List.iter (fun mt -> match mt with
| TClassDecl c when is_parent csup c ->
let rec loop c =
(try
let cf = PMap.find n (if stat then c.cl_statics else c.cl_fields) in
(* if it's clear that the class is kept, the field has to be kept as well. This is also true for
extern interfaces because we cannot remove fields from them *)
if Meta.has Meta.Used c.cl_meta || (csup.cl_interface && csup.cl_extern) then mark_field dce c cf stat
(* otherwise it might be kept if the class is kept later, so mark it as :?used *)
else if not (Meta.has Meta.MaybeUsed cf.cf_meta) then begin
cf.cf_meta <- (Meta.MaybeUsed,[],cf.cf_pos) :: cf.cf_meta;
dce.marked_maybe_fields <- cf :: dce.marked_maybe_fields;
end
with Not_found ->
(* if the field is not present on current class, it might come from a base class *)
(match c.cl_super with None -> () | Some (csup,_) -> loop csup))
in
loop c
| _ -> ()
) dce.com.types
(* expr and field evaluation *)
let opt f e = match e with None -> () | Some e -> f e
let rec to_string dce t = match t with
| TInst(c,tl) ->
field dce c "toString" false;
| TType(tt,tl) ->
if not (List.exists (fun t2 -> Type.fast_eq t t2) dce.ts_stack) then begin
dce.ts_stack <- t :: dce.ts_stack;
to_string dce (apply_params tt.t_params tl tt.t_type)
end
| TAbstract({a_impl = Some c} as a,tl) ->
if Meta.has Meta.CoreType a.a_meta then
field dce c "toString" false
else
to_string dce (Abstract.get_underlying_type a tl)
| TMono r ->
(match !r with
| Some t -> to_string dce t
| _ -> ())
| TLazy f ->
to_string dce (!f())
| TDynamic t ->
if t == t_dynamic then
()
else
to_string dce t
| TEnum _ | TFun _ | TAnon _ | TAbstract({a_impl = None},_) ->
(* if we to_string these it does not imply that we need all its sub-types *)
()
and field dce c n stat =
let find_field n =
if n = "new" then match c.cl_constructor with
| None -> raise Not_found
| Some cf -> cf
else PMap.find n (if stat then c.cl_statics else c.cl_fields)
in
(try
let cf = find_field n in
mark_field dce c cf stat;
with Not_found -> try
if c.cl_interface then begin
let rec loop cl = match cl with
| [] -> raise Not_found
| (c,_) :: cl ->
try field dce c n stat with Not_found -> loop cl
in
loop c.cl_implements
end else match c.cl_super with Some (csup,_) -> field dce csup n stat | None -> raise Not_found
with Not_found -> try
match c.cl_kind with
| KTypeParameter tl ->
let rec loop tl = match tl with
| [] -> raise Not_found
| TInst(c,_) :: cl ->
(try field dce c n stat with Not_found -> loop cl)
| t :: tl ->
loop tl
in
loop tl
| _ -> raise Not_found
with Not_found ->
if dce.debug then prerr_endline ("[DCE] Field " ^ n ^ " not found on " ^ (s_type_path c.cl_path)) else ())
and mark_directly_used_class c =
if not (Meta.has Meta.DirectlyUsed c.cl_meta) then
c.cl_meta <- (Meta.DirectlyUsed,[],c.cl_pos) :: c.cl_meta
and mark_directly_used_enum e =
if not (Meta.has Meta.DirectlyUsed e.e_meta) then
e.e_meta <- (Meta.DirectlyUsed,[],e.e_pos) :: e.e_meta
and mark_directly_used_mt mt =
match mt with
| TClassDecl c ->
mark_directly_used_class c
| TEnumDecl e ->
mark_directly_used_enum e
| _ ->
()
and check_dynamic_write dce fa =
let n = field_name fa in
check_and_add_feature dce ("dynamic_write");
check_and_add_feature dce ("dynamic_write." ^ n)
and check_anon_optional_write dce fa =
let n = field_name fa in
check_and_add_feature dce ("anon_optional_write");
check_and_add_feature dce ("anon_optional_write." ^ n)
and check_anon_write dce fa =
let n = field_name fa in
check_and_add_feature dce ("anon_write");
check_and_add_feature dce ("anon_write." ^ n)
and is_array t = match follow t with
| TAbstract(a,tl) when not (Meta.has Meta.CoreType a.a_meta) -> is_array (Abstract.get_underlying_type a tl)
| TInst({ cl_path = ([], "Array")},_) -> true
| _ -> false
and is_dynamic t = match follow t with
| TAbstract(a,tl) when not (Meta.has Meta.CoreType a.a_meta) -> is_dynamic (Abstract.get_underlying_type a tl)
| TDynamic _ -> true
| _ -> false
and is_string t = match follow t with
| TAbstract(a,tl) when not (Meta.has Meta.CoreType a.a_meta) -> is_string (Abstract.get_underlying_type a tl)
| TInst( { cl_path = ([], "String")}, _) -> true
| _ -> false
and is_const_string e = match e.eexpr with
| TConst(TString(_)) -> true
| _ -> false
and expr dce e =
mark_t dce e.epos e.etype;
match e.eexpr with
| TNew(c,pl,el) ->
mark_class dce c;
mark_directly_used_class c;
field dce c "new" false;
List.iter (expr dce) el;
List.iter (mark_t dce e.epos) pl;
| TVar (v,e1) ->
opt (expr dce) e1;
mark_t dce e.epos v.v_type;
| TCast(e, Some mt) ->
check_feature dce "typed_cast";
mark_mt dce mt;
mark_directly_used_mt mt;
expr dce e;
| TObjectDecl(vl) ->
check_and_add_feature dce "has_anon";
List.iter (fun (_,e) -> expr dce e) vl;
| TTypeExpr mt ->
mark_mt dce mt;
mark_directly_used_mt mt;
| TTry(e, vl) ->
expr dce e;
List.iter (fun (v,e) ->
if v.v_type != t_dynamic then check_feature dce "typed_catch";
expr dce e;
mark_t dce e.epos v.v_type;
) vl;
| TCall ({eexpr = TLocal ({v_name = "`trace"})},[p;{ eexpr = TObjectDecl(v)}]) ->
check_and_add_feature dce "has_anon_trace";
List.iter (fun (_,e) -> expr dce e) v;
expr dce p;
| TCall ({eexpr = TLocal ({v_name = "__define_feature__"})},[{eexpr = TConst (TString ft)};e]) ->
Hashtbl.replace dce.curclass.cl_module.m_extra.m_features ft true;
check_feature dce ft;
expr dce e;
(* keep toString method when the class is argument to Std.string or haxe.Log.trace *)
| TCall ({eexpr = TField({eexpr = TTypeExpr (TClassDecl ({cl_path = (["haxe"],"Log")} as c))},FStatic (_,{cf_name="trace"}))} as ef, ((e2 :: el) as args))
| TCall ({eexpr = TField({eexpr = TTypeExpr (TClassDecl ({cl_path = ([],"Std")} as c))},FStatic (_,{cf_name="string"}))} as ef, ((e2 :: el) as args)) ->
mark_class dce c;
to_string dce e2.etype;
begin match el with
| [{eexpr = TObjectDecl fl}] ->
begin try
begin match List.assoc "customParams" fl with
| {eexpr = TArrayDecl el} ->
List.iter (fun e -> to_string dce e.etype) el
| _ ->
()
end
with Not_found ->
()
end
| _ ->
()
end;
expr dce ef;
List.iter (expr dce) args;
| TCall ({eexpr = TConst TSuper} as e,el) ->
mark_t dce e.epos e.etype;
List.iter (expr dce) el;
| TBinop(OpAdd,e1,e2) when is_dynamic e1.etype || is_dynamic e2.etype ->
check_and_add_feature dce "add_dynamic";
expr dce e1;
expr dce e2;
| TBinop( (OpAdd | (OpAssignOp OpAdd)),e1,e2) when ((is_string e1.etype || is_string e2.etype) && not ( is_const_string e1 && is_const_string e2)) ->
check_and_add_feature dce "unsafe_string_concat";
expr dce e1;
expr dce e2;
| TArray(({etype = TDynamic t} as e1),e2) when t == t_dynamic ->
check_and_add_feature dce "dynamic_array_read";
expr dce e1;
expr dce e2;
| TBinop( (OpAssign | OpAssignOp _), ({eexpr = TArray({etype = TDynamic t},_)} as e1), e2) when t == t_dynamic ->
check_and_add_feature dce "dynamic_array_write";
expr dce e1;
expr dce e2;
| TArray(({etype = t} as e1),e2) when is_array t ->
check_and_add_feature dce "array_read";
expr dce e1;
expr dce e2;
| TBinop( (OpAssign | OpAssignOp _), ({eexpr = TArray({etype = t},_)} as e1), e2) when is_array t ->
check_and_add_feature dce "array_write";
expr dce e1;
expr dce e2;
| TBinop(OpAssign,({eexpr = TField(_,(FDynamic _ as fa) )} as e1),e2) ->
check_dynamic_write dce fa;
expr dce e1;
expr dce e2;
| TBinop(OpAssign,({eexpr = TField(_,(FAnon cf as fa) )} as e1),e2) ->
if Meta.has Meta.Optional cf.cf_meta then
check_anon_optional_write dce fa
else
check_anon_write dce fa;
expr dce e1;
expr dce e2;
| TBinop(OpAssignOp op,({eexpr = TField(_,(FDynamic _ as fa) )} as e1),e2) ->
check_dynamic_write dce fa;
expr dce e1;
expr dce e2;
| TBinop(OpAssignOp op,({eexpr = TField(_,(FAnon cf as fa) )} as e1),e2) ->
if Meta.has Meta.Optional cf.cf_meta then
check_anon_optional_write dce fa
else
check_anon_write dce fa;
expr dce e1;
expr dce e2;
| TBinop(OpEq,({ etype = t1} as e1), ({ etype = t2} as e2) ) when is_dynamic t1 || is_dynamic t2 ->
check_and_add_feature dce "dynamic_binop_==";
expr dce e1;
expr dce e2;
| TBinop(OpEq,({ etype = t1} as e1), ({ etype = t2} as e2) ) when is_dynamic t1 || is_dynamic t2 ->
check_and_add_feature dce "dynamic_binop_!=";
expr dce e1;
expr dce e2;
| TBinop(OpMod,e1,e2) ->
check_and_add_feature dce "binop_%";
expr dce e1;
expr dce e2;
| TBinop(OpUShr,e1,e2) ->
check_and_add_feature dce "binop_>>>";
expr dce e1;
expr dce e2;
| TField(e,fa) ->
begin match fa with
| FStatic(c,cf) ->
mark_class dce c;
mark_field dce c cf true;
| FInstance(c,_,cf) ->
mark_class dce c;
mark_field dce c cf false;
| _ ->
let n = field_name fa in
(match fa with
| FAnon cf ->
if Meta.has Meta.Optional cf.cf_meta then begin
check_and_add_feature dce "anon_optional_read";
check_and_add_feature dce ("anon_optional_read." ^ n);
end else begin
check_and_add_feature dce "anon_read";
check_and_add_feature dce ("anon_read." ^ n);
end
| FDynamic _ ->
check_and_add_feature dce "dynamic_read";
check_and_add_feature dce ("dynamic_read." ^ n);
| _ -> ());
begin match follow e.etype with
| TInst(c,_) ->
mark_class dce c;
field dce c n false;
| TAnon a ->
(match !(a.a_status) with
| Statics c ->
mark_class dce c;
field dce c n true;
| _ -> ())
| _ -> ()
end;
end;
expr dce e;
| TThrow e ->
check_and_add_feature dce "has_throw";
to_string dce e.etype;
expr dce e
| _ ->
Type.iter (expr dce) e
let fix_accessors com =
List.iter (fun mt -> match mt with
| (TClassDecl c) ->
let rec has_accessor c n stat =
PMap.mem n (if stat then c.cl_statics else c.cl_fields)
|| match c.cl_super with Some (csup,_) -> has_accessor csup n stat | None -> false
in
let check_prop stat cf =
(match cf.cf_kind with
| Var {v_read = AccCall; v_write = a} ->
let s = "get_" ^ cf.cf_name in
cf.cf_kind <- Var {v_read = if has_accessor c s stat then AccCall else AccNever; v_write = a}
| _ -> ());
(match cf.cf_kind with
| Var {v_write = AccCall; v_read = a} ->
let s = "set_" ^ cf.cf_name in
cf.cf_kind <- Var {v_write = if has_accessor c s stat then AccCall else AccNever; v_read = a}
| _ -> ())
in
List.iter (check_prop true) c.cl_ordered_statics;
List.iter (check_prop false) c.cl_ordered_fields;
| _ -> ()
) com.types
let run com main full =
let dce = {
com = com;
full = full;
std_dirs = if full then [] else List.map Common.unique_full_path com.std_path;
debug = Common.defined com Define.DceDebug;
added_fields = [];
follow_expr = expr;
marked_fields = [];
marked_maybe_fields = [];
t_stack = [];
ts_stack = [];
features = Hashtbl.create 0;
curclass = null_class;
} in
begin match main with
| Some {eexpr = TCall({eexpr = TField(e,(FStatic(c,cf)))},_)} ->
cf.cf_meta <- (Meta.Keep,[],cf.cf_pos) :: cf.cf_meta
| _ ->
()
end;
List.iter (fun m ->
List.iter (fun (s,v) ->
if Hashtbl.mem dce.features s then Hashtbl.replace dce.features s (v :: Hashtbl.find dce.features s)
else Hashtbl.add dce.features s [v]
) m.m_extra.m_if_feature;
) com.modules;
(* first step: get all entry points, which is the main method and all class methods which are marked with @:keep *)
List.iter (fun t -> match t with
| TClassDecl c ->
let keep_class = keep_whole_class dce c && (not c.cl_extern || c.cl_interface) in
let loop stat cf =
if keep_class || keep_field dce cf then mark_field dce c cf stat
in
List.iter (loop true) c.cl_ordered_statics;
List.iter (loop false) c.cl_ordered_fields;
begin match c.cl_constructor with
| Some cf -> loop false cf
| None -> ()
end;
begin match c.cl_init with
| Some e when keep_class || Meta.has Meta.KeepInit c.cl_meta ->
(* create a fake field to deal with our internal logic (issue #3286) *)
let cf = mk_field "__init__" e.etype e.epos in
cf.cf_expr <- Some e;
loop true cf
| _ ->
()
end;
| TEnumDecl en when keep_whole_enum dce en ->
mark_enum dce en
| _ ->
()
) com.types;
if dce.debug then begin
List.iter (fun (c,cf,_) -> match cf.cf_expr with
| None -> ()
| Some _ -> print_endline ("[DCE] Entry point: " ^ (s_type_path c.cl_path) ^ "." ^ cf.cf_name)
) dce.added_fields;
end;
(* second step: initiate DCE passes and keep going until no new fields were added *)
let rec loop () =
match dce.added_fields with
| [] -> ()
| cfl ->
dce.added_fields <- [];
(* extend to dependent (= overriding/implementing) class fields *)
List.iter (fun (c,cf,stat) -> mark_dependent_fields dce c cf.cf_name stat) cfl;
(* mark fields as used *)
List.iter (fun (c,cf,stat) ->
if not (is_extern_field cf) then mark_class dce c;
mark_field dce c cf stat;
mark_t dce cf.cf_pos cf.cf_type
) cfl;
(* follow expressions to new types/fields *)
List.iter (fun (c,cf,_) ->
dce.curclass <- c;
opt (expr dce) cf.cf_expr;
List.iter (fun cf -> if cf.cf_expr <> None then opt (expr dce) cf.cf_expr) cf.cf_overloads
) cfl;
loop ()
in
loop ();
(* third step: filter types *)
let rec loop acc types =
match types with
| (TClassDecl c) as mt :: l when keep_whole_class dce c ->
loop (mt :: acc) l
| (TClassDecl c) as mt :: l ->
let check_property cf stat =
let add_accessor_metadata cf =
if not (Meta.has Meta.Accessor cf.cf_meta) then cf.cf_meta <- (Meta.Accessor,[],c.cl_pos) :: cf.cf_meta
in
begin match cf.cf_kind with
| Var {v_read = AccCall} ->
begin try
add_accessor_metadata (PMap.find ("get_" ^ cf.cf_name) (if stat then c.cl_statics else c.cl_fields))
with Not_found ->
()
end
| _ ->
()
end;
begin match cf.cf_kind with
| Var {v_write = AccCall} ->
begin try
add_accessor_metadata (PMap.find ("set_" ^ cf.cf_name) (if stat then c.cl_statics else c.cl_fields))
with Not_found ->
()
end
| _ ->
()
end;
in
(* add :keep so subsequent filter calls do not process class fields again *)
c.cl_meta <- (Meta.Keep,[],c.cl_pos) :: c.cl_meta;
c.cl_ordered_statics <- List.filter (fun cf ->
let b = keep_field dce cf in
if not b then begin
if dce.debug then print_endline ("[DCE] Removed field " ^ (s_type_path c.cl_path) ^ "." ^ (cf.cf_name));
check_property cf true;
c.cl_statics <- PMap.remove cf.cf_name c.cl_statics;
end;
b
) c.cl_ordered_statics;
c.cl_ordered_fields <- List.filter (fun cf ->
let b = keep_field dce cf in
if not b then begin
if dce.debug then print_endline ("[DCE] Removed field " ^ (s_type_path c.cl_path) ^ "." ^ (cf.cf_name));
check_property cf false;
c.cl_fields <- PMap.remove cf.cf_name c.cl_fields;
end;
b
) c.cl_ordered_fields;
(match c.cl_constructor with Some cf when not (keep_field dce cf) -> c.cl_constructor <- None | _ -> ());
let inef cf = not (is_extern_field cf) in
let has_non_extern_fields = List.exists inef c.cl_ordered_fields || List.exists inef c.cl_ordered_statics in
(* we keep a class if it was used or has a used field *)
if Meta.has Meta.Used c.cl_meta || has_non_extern_fields then loop (mt :: acc) l else begin
(match c.cl_init with
| Some f when Meta.has Meta.KeepInit c.cl_meta ->
(* it means that we only need the __init__ block *)
c.cl_extern <- true;
loop (mt :: acc) l
| _ ->
if dce.debug then print_endline ("[DCE] Removed class " ^ (s_type_path c.cl_path));
loop acc l)
end
| (TEnumDecl en) as mt :: l when Meta.has Meta.Used en.e_meta || en.e_extern || keep_whole_enum dce en ->
loop (mt :: acc) l
| TEnumDecl e :: l ->
if dce.debug then print_endline ("[DCE] Removed enum " ^ (s_type_path e.e_path));
loop acc l
| mt :: l ->
loop (mt :: acc) l
| [] ->
acc
in
com.types <- loop [] (List.rev com.types);
(* extra step to adjust properties that had accessors removed (required for Php and Cpp) *)
fix_accessors com;
(* remove "override" from fields that do not override anything anymore *)
List.iter (fun mt -> match mt with
| TClassDecl c ->
c.cl_overrides <- List.filter (fun s ->
let rec loop c =
match c.cl_super with
| Some (csup,_) when PMap.mem s.cf_name csup.cl_fields -> true
| Some (csup,_) -> loop csup
| None -> false
in
loop c
) c.cl_overrides;
| _ -> ()
) com.types;
(* mark extern classes as really used if they are extended by non-extern ones *)
List.iter (function
| TClassDecl ({cl_extern = false; cl_super = Some ({cl_extern = true} as csup, _)}) ->
mark_directly_used_class csup
| TClassDecl ({cl_extern = false} as c) when c.cl_implements <> [] ->
List.iter (fun (iface,_) -> if (iface.cl_extern) then mark_directly_used_class iface) c.cl_implements;
| _ -> ()
) com.types;
(* cleanup added fields metadata - compatibility with compilation server *)
let rec remove_meta m = function
| [] -> []
| (m2,_,_) :: l when m = m2 -> l
| x :: l -> x :: remove_meta m l
in
List.iter (fun cf -> cf.cf_meta <- remove_meta Meta.Used cf.cf_meta) dce.marked_fields;
List.iter (fun cf -> cf.cf_meta <- remove_meta Meta.MaybeUsed cf.cf_meta) dce.marked_maybe_fields;
haxe_3.2.1+dfsg.orig/extra/CHANGES.txt 0000664 0001750 0001750 00000221402 12607337712 017261 0 ustar andy andy 0000000 0000000 2015-10-11: 3.2.1
Bugfixes:
cs/java : fixed `-dce no` issues
cs/java : fixed how KExpr type parameters are generated
cs : fixed enum creation by reflection problem
cpp : do not rely in reflection to make interfaces work for non-first interface parents
cpp : fixed setting of static variables via reflection when class has no member variables
cpp : make sure StringMap's h field is kept if we use StringMap
js : Avoid the use of `eval`/`Function` to get the top-level defined type/var to not break ContentSecurityPolicy
2015-05-12: 3.2.0
New features:
all : added @:noPrivateAccess to re-enable access restrictions within @:privateAccess
cpp : some support for @:nativeGen metadata
Bugfixes:
all : fixed detection of @:generic classes with constructor constraints
all : fixed variable initialization check issue in loop condition
all : fixed pattern matching on @:enum abstracts via field access (#4084)
all : fixed missing implicit casts in Map literals (#4100)
all : fixed various minor issues in haxe.xml.Parser
all : fixed class path issue when HAXE_STD_PATH is set (#4163)
js : fixed DCE issue related to printing enums (#4197)
js : fixed various issues with the new Bytes implementation
php : fixed EOF handling in FileInput.readByte (#4082)
cs/java : fixed Math.fround implementation (#4177)
cs/java : fixed some cases of Std.parseInt failing (#4132)
cpp : fixed compilation without -main (#4199)
General improvements and optimizations:
all : --macro keep no longer causes types to be included for compilation
php : support interpolation in __php__ code
js : added variable number of arguments support in js.html.* classes
js : refined new HTML externs
Macro features and changes:
macro : [breaking] synced FClosure and FInstance with the compiler updates
2015-03-15: 3.2.0-RC1
This release removes support for Flash 8 target
New features:
all : added --display mode for toplevel completion
all : added --display mode for position and usage information
all : allowed @:callable on abstracts to forward calls to their underlying type
all : allowed pattern matching on getters
all : allowed @:native on class fields
all : added static analyzer with constant propagation
all : added Haxe-based XML implementation
python : added python target
flash : flash player 12-14 support
js : added @:jsRequire and js.Lib.require
js : support haxe.CallStack.exceptionStack
cs : added @:bridgeProperties
cs : added -D erase_generics
cs : added -D dll_import to import haxe-generated dlls
java/cs : added `sys.db` package
java/cs : clean unused files in output folder, unless `-D keep_old_output` is defined
java/cs : added `-c-arg` to add C#/Java compiler arguments
cpp : inititial implementation of cppia scripting
Bugfixes:
all : fixed nullability of abstracts over functions
all : fixed some equality checks between UInt and Int
all : fixed rare issue with abstract casts
all : fixed some internal code which relied on unspecified evaluation order
all : fixed exhaustiveness checks involving guards
all : fixed issue involving recursively constrained type parameters and @:generic
all : fixed type inference issue in map literals
all : fixed type inference issue when calling abstract method from within the abstract
all : fixed several abstract variance issues
all : fixed DCE issues with interface properties
all : fixed variance issue with function variables and dynamic methods on interfaces
all : fixed pattern matching on empty arrays that are typed as Dynamic
all : fixed various @:generic issues
all : fixed default cases on @:enum abstract being omitted
all : fixed various expression positions
all : disallowed break/continue in closures in loops
all : disallowed inline functions in value places
all : fixed parsing of cast followed by parentheses
all : fixed resource naming in case of invalid file system characters
all : fixed issue with inlined array declarations with field access
cpp : fixed issue with the side-effect handler
cpp : fixed issue with NativeArray in --no-inline mode
php : fixed issue with invalid references for closures in for-loops
php : fixed Reflect.compare and string comparison for numeric strings
cs/java : fixed various issues with -java-lib and -net-lib.
cs/java : added @:libType to skip checking on -java-lib / -net-lib types
cs/java : compilation server now works with C#/Java [experimental support]
cs : fixed Type.enumIndex / switch on C# native enums
cs : fixed reflection on COM types
java : fixed sys.net.Socket server implementation
spod : various fixes - working now on cpp, java, neko, php and c#
cpp : improved boot order, with enums constants first
General improvements and optimizations:
all : disallowed using `super` in value positions
all : check exhaustiveness of explicit Null types
all : resolve unqualified identifiers to @:enum abstract constructors
all : determine @:generic type parameters from constructor call if possible
all : properly disallowed field redefinition in extending interface
all : properly disallowed leading zeroes for Int and Float literals
all : allowed variance on interface variables
all : allowed pattern matching on arrays if they are typed as Dynamic
all : allowed pattern matching on fields of parent classes
all : -D doc-gen no longer implies -dce no
all : allowed matching against null on any enum instance
flash/js: optimized haxe.ds.StringMap
neko : create output directory if it does not exist
js : inline Math methods and fields
cs/java : optimized Reflect.fields on dynamic structures
cs/java : haxe will now clear output directory of old files (use -D keep-old-output to keep them)
cs : optimized field lookup structure
cs : optimized casting of parametrized types
cs : beautify c# code output
cs : added `cs.Flags` to manipulate C# enums that can be also flags
xml : improved documentation generation and fixed missing entity escaping
cpp : property access via Dynamic variables now requires property to be declared with @:nativeProperty
cpp : allow injection of code from relative paths using @:sourceFile and @:cppInclude
cpp : stronger typing of native functions via cpp.Function + cpp.Callable
cpp : moved 'Class' implementation to hx namespace to improve objective C interaction
cpp : added file_extension define to change the output filename extension (eg, ".mm")
cpp : added pre-calculated hashes to string constants to allow faster lookups
cpp : map implementation allows strongly typed interactions in some cases (avoids boxing)
cpp : added native WeakMap implementation
cpp : put each resource into own cpp file to allow more data/smaller files
Standard Library:
all : added typed arrays to haxe.io package
all : added haxe.ds.Either
all : added haxe.extern.Rest type for representing "rest" arguments in extern method signatures
all : added haxe.extern.EitherType abstract type for dealing with externs for dynamic targets
all : added haxe.DynamicAccess type for working with dynamic anonymous structures using a Map-like interface
all : [breaking] changed haxe.ds.Vector.get to return T instead of Null
all : added haxe.macro.Compiler.addGlobalMetadata
all : changed haxe.Int64 to be an abstract type instead of a class
js : updated HTML externs
Macro features and changes:
macro : added Context.getLocalTVars
macro : added TypedExprTools.iter
macro : added Context.getCallArguments
macro : changed @:genericBuild macros to prefer ComplexType returns
macro : [breaking] extended TAnonymous structures now have AExtend status instead of AClosed
macro : added Context.getDefines
macro : fixed file_seek from end (position was inversed)
macro : added Context.storeTypedExpr
macro : allowed type name reification
Deprecations:
all : deprecated structurally extending classes and interfaces
sys : Sys.command shell special chars (&|<>#;*?(){}$) are now properly escaped
java/cs : Lib.nativeType is now renamed to Lib.getNativeType
2014-04-13: 3.1.3
Bugfixes:
all : fixed handling of abstract variance
flash : ensure correct endianess in haxe.io.BytesBuffer
cpp : fixed issue involving class paths with spaces
php : fixed >>>
macro : fixed haxe.macro.Compiler.keep
General improvements and optimizations:
all : give @:deprecated warnings by default, allow -D no-deprecation-warnings
cpp : optimized Vector implementation
Standard Library:
all : renamed Bytes.readDouble/Float to getDouble/Float to avoid inheritance issues
all : deprecated Bytes.readString in favor of getString
all : added pretty-printing to haxe.format.JsonPrinter (and haxe.Json)
2014-03-29: 3.1.2
Bugfixes:
all : disallowed spaces between >>, >>>, >>= and >>>=
all : fix branching issue when switching on Dynamic values with only one case
all : added missing abstract cast call when checking for equality
all : fixed member fields initializations on parent classes that have no constructor
all : fixed toString usage of abstracts which are argument to Std.string
flash : avoid rare FP 12 PPAPI JIT crash
cpp : fixed bug in side-effect handler which caused incorrect behavior of while loops
js : fixed missing print function for enum values with DCE
macro : make sure member field initializations are respected
General improvements and optimizations:
all : cached file exist checks to speed up compilations with a lot of class paths
all : improved completion related to super class fields
all : allowed iterating on abstract which have get_length and @:arrayAccess fields
js : improved Type.allEnums implementation to avoid issues with obfuscation
Standard Library:
all : added haxe.io.Bytes.readDouble/Float
all : added haxe.io.BytesBuffer.addString/Float/Double
2014-03-15: 3.1.1
New features:
all : added -D deprecation-warnings
all : allowed \u escape sequences in strings
cs : implemented haxe.CallStack
Bugfixes:
all : fixed wrong handling of "" and null in haxe.io.Path.join
all : fixed invalid cast-to-self generation on some abstracts
all : removed @:to Dynamic from UInt to avoid issues in the Map selection algorithm
all : fixed various issues with UInt
all : fixed position setter in haxe.io.BytesInput
all : fixed various issues with member/static extension macros
flash : fixed invalid override involving single-constraint type parameters
flash8 : fixed various bugs
js : fixed a problem with Std.string(null) being optimized incorrectly
js : fixed custom generators
cpp : dealt with string literals that are too long for MSVC
cs : fixed various issues with -net-lib
2014-03-04: 3.1.0
New features:
all : allowed null-patterns in pattern matching
all : allowed extractors in pattern matching using => syntax
all : allowed extending generic type parameters
all : allowed (expr : type) syntax (ECheckType)
all : allowed @:enum and @:forward on abstracts
all : allowed using abstracts as static extension
all : allowed Class.new
all : added EnumValue.match
all : allow multiple structural extension using { > T1, > T2, fields }
all : inline array and structure declarations if possible
cs : added -net-lib
cs : support for native delegates
cs : support for attributes
cs : support for events
Standard Library:
all : support abstract types in haxe.rtti.XmlParser
all : added Std.instance
all : added length field to BytesBuffer, BytesOutput, BytesInput and StringBuf
all : added UInt for all targets
all : added Array.indexOf and Array.lastIndexOf
all : added haxe.xml.Printer
all : added haxe.Int32 as abstract type
all : added haxe.format.JsonParser/Printer
General improvements and optimizations:
all : optimized pattern matching output
all : allowed recursive type parameter constraints
all : improved support of custom @:coreType abstracts
all : evaluate conditional expressions in @:require
all : improved inline constructors by detecting more cases where it can be applied
js : improved inlining
js : always use JSON extern (compile with -D old-browser to disable)
js : added -D js-flatten
js : added -D js-es5
cpp : improved side-effect detection
Bugfixes:
all : inlining a parameter which has side effects will not remove it even if not used
all : implemented constraints check on enum and enum field type parameters
all : fixed memory leak in compilation server and optimized caching in general
all : fixed issue with invalid lowercase class name in Windows completion
flash : fixed font embedding with UTF8 chars
flash : give error if non-nullable basic types are skipped in a call
flash : give error if assigned parent class field values would be overwritten by super()
Macro features and changes:
macro : add Context.onAfterGenerate
macro : add Context.typeExpr
macro : add Context.getExpectedType
macro : add ExprTools.getValue
macro : allowed $v{(c:Float|Int|String)}
macro : resolve error line number in external files
macro : rewrote macros used as static extension
macro : exposed typed AST
macro : added @:genericBuild
macro : [breaking] first argument of ComplexType.TExtend is now Array instead of TypePath
macro : improved expression printing
2013-09-25: 3.0.1
all : minor DCE bug fix
2013-05-25: 3.0.0
all : added haxe.ds.BalancedTree
all : added haxe.ds.EnumValueMap
all : allow enum constructors as keys to Map
all : haxe.ds.ObjectMap is now correctly constrained on all targets
all : preliminary support of -D display-mode=usage|position|metadata
all : improved pattern matcher error messages
all : allow inline constructors
all : allow abstract member macros (not for @:op, @:arrayAccess, @:from, @:to)
all : allow abstract type parameter variance
all : do not generate hidden null on if without else
macro : made abstract structure available
2013-05-08: 3.0.0-RC2
all : improved abstract support
all : renamed HAXE_LIBRARY_PATH to HAXE_STD_PATH
all : added inlinable constructors
all : renamed haxe.ds.FastCell to GenericCell
all : fixed >= operator in #if conditionals
all : improved completion support for Unknown results
all : allowed [] access for Map
all : added haxe.ds.WeakMap (not yet supported on all platforms)
all : all trace parameters are now printed by default
all : added --help-metas
all : improved completion
all : improved pattern matching variable capture and GADT support
js : cached $bind results (unique closure creation per instance)
js : removed --js-modern (now as default)
cpp : added socket.setFastSend
flash : update player 11.7 api
flash : improved @:font, @:sound and @:bitmap support
neko/java/cs : improved Array performances when growing with []
java : added -java-lib support
java : added sys.net package implementation (alpha)
java : complete java std library through hxjava haxelib
java/cs : added support for overloaded function declarations
java/cs : overload selection algorithm
cs : operator overloading is now accessible through Haxe
cs : source mapping; can be disabled with -D real_position
as3 : fixed rare syntax ambiguity
php : removed initialization of some inline fields
macro : fixed several issues with 'using' a macro function
macro : improved expression printing
2013-02-24: 3.0.0-RC
flash : updated player 11.4 api
all : allowed named functions as r-value
all : fixed using + overload usage
all : allow any type constraint for type parameters
all : make property type optional (when a initial value is set)
all : Std.random(x) when x <= 0 is now always 0
spod : added serialized data with SData
all : Dispatcher will now throw DETooManyValues
all : speed up neko compilation by using native compiler
all : allow @:generic on functions
all : allow constructing generic type parameters
swf : added support for SWC files in -swf-lib
macro : added Context.onTypeNotFound callback for unresolved types
js : no JS embed as default (use -D embed-js instead)
all : added abstract types (Int/Float/Bool/Void/Class/Enum/EnumValue)
all : added --help-defines
all : changed DCE with three modes : std(default), no and full
all : Haxe3 packages changes (see http://haxe.org/manual/haxe3)
all : Removed haxe.Int32, haxe.Firebug, haxe.TimerQueue
all : added -D key=value and #if (key >= value) operations
all : StringTools.htmlEscape/unescape nows handle "/" and '/'
all : using and import must now appear before any type declaration in a file
all : no longer create variable fields for pure getter/setter properties (unless @:isVar is used)
all : use default get_prop/set_prop instead of custom getter/setter names for properties
js : added JQuery.delegateTarget
macro : removed EType and CType, added EMeta, modified ESwitch
all : allow @metadata expr
all : replaced haxe.rtti.Generic interface with @:generic metadata
all : no longer infer arrays of mixed types as Array
all : all type/import/enum constructor resolution now follows the shadowing principle (latest has priority)
all : added EReg.matchSub, renamed EReg.customReplace to map
all : no longer allow initialization of extern non-inline variables
swf : fixed out of memory errors on very large swf-lib files
swf : added -D swf_preloader_frame, swf_gpu, swf_direct_blit
swf : added -D swf_script_timeout=seconds, swf_debug_password=password, swf_metadata=file
swf : added -swf-lib-extern
swf : added @:font support (beta)
all : added GADT support in enums
all : added pattern matching (beta)
all : changed callback(func, args) to func.bind(args)
macro : added haxe.macro.ExprTools/ComplexTypeTools/TypeTools
macro : changed reification syntax to ${expr}, $a{array}, $p{path}, $v{value}
macro : allow macro @:pos(pos-expr) to inject positions for reification
all : added array comprehension
flash : Vector.length is now Int instead of UInt
all : moved haxe.BaseCode, haxe.Md5 and haxe.SHA1 to haxe.crypto package
all : disallow Void variables and arguments (still allow S -> T to S -> Void)
all : added Array.map/filter
all : added spell check suggestions for enum constructors and fields
all : added opaque abstract(T) types
all : allow operator overloading on opaque abstract types
all : renamed IntIter to IntIterator
all : added Map
all : added haxe.ds with StringMap, IntMap, HashMap, ObjectMap, Vector, GenericStack
all : removed Hash, IntHash and haxe.FastList in favor of the types in haxe.ds
all : haxe.xml.Parser now handles entities consistently across platforms
all : renamed HAXE_LIBRARY_PATH environment variable to HAXE_STD_PATH
2012-07-16: 2.10
java/cs : added two new targets (beta)
all : fixed List and Null for first, last, pop
js : added js.Lib.debug()
flash : fixed Xml.parent() when no parent
flash : fixed haxe.io.Bytes.blit when len=0
js/php/flash8 : fixed haxe.Int32.mul overflow on 52 bits
js : fixed haxe.Utf8 usage (static 'length' issue)
all : does not allow overriding var/prop
flash : removed wrapping for Xml nodes, use instead specific compare when comparing two typed nodes
js : use new haxe.xml.Parser (faster, not based on Regexp)
flash : fixed completion issue with for( x in Vector )
all : optimized Std.int(123) and Std.int(123.45)
flash : bugfix for @:bitmap with 24-bits PNG (flash decode wrong colors)
as3 : fixed EnumValue becomes Object
js : removed js.Lib.isIE/isOpera (not complete, use js.JQuery.browser instead)
all : function parameters are nullable if they are declared with '?'
all : added support for finding common base types of multiple types (unify_min) for array, switch, if
php : do not implement duplicate interfaces
haxelib : added git support through haxelib git
all : allow derived classes to widen method visibility
macro : added haxe.macro.Context.getLocalMethod
macro : improved support of "using" macro functions
php : optimized Xml implementation
php : fixed Reflect.get/setProperty not working on PHP < 5.3
all : support for callback(f, _, x)
all : allow private access between classes that have a common base class
all : added Output.writeFloat/Double and Input.readFloat/Double
all : support for var:{x:Float} = { x = 1 } constant structure subtyping
all : allow contravariant function arguments and covariant function returns in overrides
macro : support for final Array argument as rest argument
macro : use top-down inference on macro calls
all : made "using" imply "import"
all : made String concat more consistent across platforms (add Std.string wrappers)
all : allow direct member variable/property and static property initialization
js : greatly reduced amount of generated code by using smarter DCE
php : made modulo operations more consistent
all : allow local functions to have both type parameters and be inlined
all : functions type parameters can be constraint (will be checked at end of compilation)
macro : use NekoVM runtime for regexps, process and xml parsing
flash : allow @:getter/@:setter in interfaces
flash : added support for "arguments" in methods
all : not used enums and inline var/methods are now removed by DCE
all : allow @:overload to use type parameters and not-absolute type paths
all : ensure that Std.string of arrays and enums are now consistent across platforms
all : allow to inline functions containing other functions
xml : added metadata output to xml generator
macro : added macro and macro : reification
all : renamed type(e) to $type(e)
as3 : support for metadata and resources, and other fixes
2012-04-14: 2.09
all : optimized const == const and const != const (with different const types)
all : add Type.allEnums(e)
all : big improvements with completion speed and fixed many issues
flash9 : fixed -D swfprotected with swc output
neko : added ~ implementation
js : upgraded jquery version, more api overloads
sys : added "in" operator for spod macros, added relation access in expressions
macro : added ECheckType
macro : added TLazy for not-yet-typed class fields
js/php/neko : added haxe.web.Request
all : added Std.format
js : trace() output fallback on console.log if no id="haxe:trace"
all : ensure that Std.is(2.0,Int) returns true on all platforms
js : replaced $closure by function.$bind + changes in output format
all : allowed @:extern on static methods (no generate + no closure + force inlining)
all : added documentation in --display infos + display overloads in completion
js : removed --js-namespace, added $hxClasses
flash : output traces to native trace() when using -D fdb or -D nativeTrace
all : allowed abitrary string fields in anonymous objects
all : allowed optional structure fields (for constant structs)
all : allowed optional args in functions types (?Int -> Void)
all : added Reflect.getProperty/setProperty (except flash8)
all : added --wait and --cwd and --connect (parsed files and module caching)
all : fixed completion in macros calls arguments
all : fixed DCE removing empty but still used interfaces/superclasses
all : added haxe.Utf8 (crossplatform)
neko : Reflect now uses $fasthash (require neko 1.8.2)
all : allow \uXXXX in regexp (although not supported everywhere)
js : make difference between values and statements expressions in JSGenApi
js : added source mapping with -debug (replace previous stack emulation)
flash : added @:file("a.dat") class File extends flash.utils.ByteArray
flash : added @:sound("file.wav|mp3") class S extends flash.media.Sound
js : added --js-modern for wrapping output in a closure and ES5 strict mode
all : null, true and false are now keywords
all : neko.io.Path, cpp.io.Path and php.io.Path are now haxe.io.Path
neko, cpp, php : added Sys class, sys.io and sys.net packages and "sys" define
all : allow to access root package with std prefix (std.Type for example)
all : added haxe.EnumFlags
sys : io.File.getChar/stdin/stdout/stderr are now in Sys class
cpp : Reflect.getField and Reflect.setField no longer call property functions. Use Reflect.getProperty and Refelect.setProperty instead.
cpp : Default arguments now use Null for performance increase and interface compatibility
cpp : Added metadata options for injecting native cpp code into headers, classes and functions
php : added php.Lib.mail
(hotfix) fixed bug in completion and disabled profiling on Linux
(hotfix) fixed $ssize when doing new String(v) in neko
(hotfix) fixed bug with properties in interfaces for Flash & PHP
2011-09-25: 2.08
js : added js.JQuery
all : added @:overload
js : upgraded js.SWFObject from 1.4.4 inlined to 1.5 embedded
js : code generator beautify
all : ensure that modifying returned Type.getEnumConstructs array does not affect enum
all : allow macro typed parameters (other than Expr)
flash : added flash11 apis
neko : added support for https to haxe.Http (using hxssl library)
all : added haxe.Int64
all : added haxe.Int32 isNeg,isZero,ucompare, fixed overflows for js/flash8/php
all : bugfix when optimizing inlined immediate function call
all : fixed "using" on macro function
all : allowed member macros functions (called as static)
neko : allowed serialization of haxe.Int32 (as Int)
all : fixed invalid optimization of two constant numbers comparison
flash8 : bugfix Std.parseInt with some hex values
flash9 : added flash.utils.RegExp
all : changed @:build behavior, now takes/returns a var with anonymous fields
all : added @:native support for enums
neko : changed the result of array-assign expression (was null)
flash9 : no longer auto create enums from SWF classes
(need explicit "enum" type patch)
all : optimized variable tracking/renaming
all : optimized macro engine (speed x2)
all : added -D macrotimes support
flash9 : store resources in bytes tag instead of bytecode
all : allow $ prefixed identifiers (for macros usage only)
all : allow to access modules subtype statics with pack.Mod.Type.value
and fixed identifier resolution order
flash9 : added @:bitmap("file") for simple embedding
all : added haxe.web.Dispatch
js : added js.Storage
all : allow this + member variables access in local functions
added untyped __this__ support and transition error
all : added haxe.macro.MacroType
neko : neko.Lib.serialize/unserialize now returns bytes
neko : added sys.db package (crossplatform with -D spod_macro support)
spod_macro now uses wrappers for Bytes (require neko 1.8.2)
php : added --php-prefix for prefixing generated files and class names
all : added type_expr_with_type enum support
php/js : fixed adding 'null' to StringBuf
all : added haxe.macro.Context.defineType
2011-01-30: 2.07
all : fixed completion support with --remap
all : added macros, added --interp
all : removed 'here' special identifier
neko : fixed neko.Web.getParamsString() returning "null" instead of ""
flash9 : fixed issue with @:bind
flash9 : added some missing errors
flash9 : fixed TypedDictionary.exists
all : added @:build and @:autoBuild for enums and classes
neko : Std.parseFloat now returns NaN with invalid string
php: fixed Array.push must return the current length (issue 219)
php: fixed EReg.replace (issue 194)
php: FileSystem.readDirectory now skips '.' and '..' to be consistent with neko (issue 226)
flash9 : add trace text on stage (always over current and subclips)
flash9 : delay SWF initialization until it's added on stage and stageWidth > 0
(this can be disabled with -D dontWaitStage)
all : added haxe.Timer.measure
all : added Lambda.indexOf and Lambda.concat
all : no longer allow inline vars as metadata values
neko : added getFieldsNames to neko.db.ResultSet (supported in Neko 1.8.2 mysql driver)
all : added --macro and haxe.macro.Compiler
all : allow macro type patches
flash9 : changed --gen-hx-classes implementation
now use 'haxe -swf-lib lib.swf --gen-hx-classes' instead
flash9 : added @:getter and @:setter
all : added @:require
flash9 : moved vector utils functions from flash.Lib to flash.Vector
flash9 : added support for FP 10.1 and 10.2
flash9 : added @:meta(Meta(k="v")) support
all : improved #if support (fixed ! precedence)
all : lookup unqualified types in all package hierarchy and not only in current package
flash : set default flash version to 10 (-swf9 deprecated, use -swf-version 8 for avm1)
php : added --php-lib to allow to rename the destination path of the generated lib
all : added --dead-code-elimination, removes unused functions from the output
(beta feature could not make in the final release)
all : added @:keep to prevent --dead-code-elimination of class/method
flash9 : fixed issues with loading a Haxe SWF (boot_XXXX class extends flash.Boot)
all : allow to inline override methods (if the superclass method is not inlined already)
all : fixed escape sequences in literal regular expressions
flash9 : fixed Xml.setNodeValue
all : removed -excluded, replaced by --macro excludeFile('filename')
all : added --macro exclude('package') and --macro include('package')
all : importing a typedef of an enum allow to access its constructors
all : removed String.cca (replaced by StringTools.fastCodeAt + StringTools.isEOF)
flash9 : fixed use of default values when null is passed for nullable basic types
all : fixed issues with inlining and class/function type parameters
all : big speedup for compiler internal completion
all : added --macro keepClass('classname')
flash9 : fixed Xml.nodeValue for comments (does not include )
all : added named local functions (allow self-recursion)
all : use left-assoc for (==,!=,>,>=,<,<=)(==,!=,>,>=,<,<=) (&&)(&&) and (||)(||)
all : give prefix unary operators higher priority than ?:
php : fixed XML parsing
cpp : many fixes
2010-08-14: 2.06
neko : change serializer to be able to handle instances of basic classes from other modules
js : add Document.createTextNode
all : bugfix with inline when modifying var with same name as one of current local
flash9 : classes implementing ArrayAccess are now dynamic (including TypedDictionary)
all : allow "using" on typedefs
as3 : minor fixes in genas3 and --gen-hx-classes
as3 : fix with readonly/writeonly properties accesses
flash9 : list native getter/setters in Type API class/instance fields
all : make haxe.rtti.Generic typing lazy (fix for self-recursion)
all : allow haxe.rtti.Generic + inheritance
all : added resource size limit to 12MB (ocaml max_string_size is 16MB + b64)
flash : changes in swf handling to work with >16MB swfs
flash9 : only init dynamic methods if not already defined (in subclass)
std : added haxe.SHA1
compiler : added TCast, allow cast optimization on flash9/cpp
as3 : fixed Std.__init__ generating 'null'
compiler : fixed -no-opt
flash : allow several -swf-lib
no longer support automatic creation of classes for f8 swfs in f9 mode
classes defined in f9 swf are not redefinable in Haxe code (use extern)
flash9 : allow direct access and completion with classes defined in -swf-lib's
flash9 : remove imported libraries debug infos when not compiled with -debug
all : only display errors with --display if no completion matched
all : some completion related errors fixed
flash9 : added @:bind support
all : fixed StringTools.hex with negative numbers
flash9 : fixed Type.typeof(1<<28) was TFloat
flash9 : use flash.XML parser for Xml class implementation
neko : fixed Array.splice (was not setting null at end of array)
neko : rewrote Array class using neko.NativeArray
all : core classes implementation are now in std/(platform)/_std
all : added @:final support
all : added haxe.rtti.Meta
flash9 : added flash.desktop.Clipboard* classes (added in flash10)
as3 : fixed Date.toString issue in flash.Boot (now use .toStringHX instead)
this will only work if .toString called explicitely on Date class
all : only allow "using" on Dynamic if first parameter is Dynamic
php : haxe.Http now supports Https connections when OpenSSL extension is enabled (issue 143)
php : fixed enum constructors sequence (issue 142)
php : added error message when using 2 fields with different cases in the same class/enum
php : fixed field declaration for properties with getter and setter (issue 124)
php : fixed comparison issues between strings (issue 132)
php : enhanced FileInput.readLine using native fgets function (issue 103)
flash9 : renamed flash.Error to flash.errors.Error
php : removed eval() everywhere and simplified _hx_lambda
php : fixed return type for Std.string() with integers and floats
php : fixed php.Lib.rethrow
all : added custom Haxe serialization
php : aligned php.Web.parseMultipart signature with neko implementation
cpp : Added source location and stack dump for errors in debug mode
cpp : Remapped more keywords
cpp : Added templated fast iterator code for arrays and FastLists
cpp : Added option for tracing GC references in debug mode
cpp : Switch the native string implementation from wchar_t to utf8 - for regex speed
cpp : Added extra "()" to ensure correct order of operations
cpp : Fixed various bugs for unusual (and not so unusual) language constructs
cpp : Fixed order of enum generation from index
cpp : Added __unsafe_get and __unsafe_set to Array as possible optimizations
cpp : Default to mult-thread compiling on windows for cl version >= 14
cpp : Seed Math.random
cpp : Use strftime for Dates
cpp : Fix socket sellect passing _s
cpp : Throw error when match count does not match regex
cpp : Improve register capture in GC
cpp : Fix Dynamic interger compare
cpp : Implement makeVarArgs
cpp : Fix toString for nulls in Enums and Arrays
cpp : Added initial Android support
cpp : Move initializers to entry functions in standard ndlls.
cpp : Changes some CFFI register funtions to char*, from wchar_t*
cpp : Added some initial support for v8 script target
cpp : Use non-recursive GC marking to avoid overflow in big lists
cpp : Added __hxcpp_obj_id
2010-01-09: 2.05
js : added js.Scroll
js : package names are now checked at runtime to avoid clashes with existing libs
js : added --js-namespace to create a namespace for types that are defined in the root
all : updated xml output and html doc - add inline, override, dynamic functions support
all : added error when comparing enum with arguments
all : optimize constant equality for enums
flash9 : fixed verify error with inline + null type
flash9 : bugfix when overriding/implementing an method with an applied type parameter
php : fixed issues with classes that implement Dynamic
all : ignore #! line at beginning of the hx file
haxelib : added tags, added documentation
flash8 : don't use b64 encoding for text ressources
php : fixed bug in Hash.exists for null values and Reflect.callMethod
js/flash9 : throw exception in Xml.parse when unclosed node
all : improve return type progagation in inlined expression (fix some VerifyErrors)
all : optimize {const} into const
all : added structure / Dynamic subtyping
all : fixed List.map2 error when inline + optional args
flash9 : encode all ISO constant strings into UTF8 at compilation time
all : allow hxml with only -cmd statements
spod : moved Manager.addQuote to Connection.addValue
flash9 : removed .iterator() from Vector (not implementable)
all : fixed haxe.rtti.Generic on interfaces
php : fixed issue with Reflect.callMethod
php : fixed issue with PHP reserved word used in callbacks
all : bugfix with non-constant enums in switches
flash9 : fix for interfaces (use namespace)
all : "using" now works for identifiers in member methods
flash9 : bugfix with switch on some big integers
all : bugfix when optimizing (function(x) return x)(x)
neko : improved speed of Xml.toString()
all : added -D dump (for debugging purposes)
neko : added neko.Web.isTora
php : added php.db.PDO (php.db.Sqlite is now deprecated)
php : fixed bug in Type.getClassFields() that reported duplicated entries
php : fixed errror in XML error reporting
all : allow sub-types declarations everywhere (pack.Type.Sub)
all : added completion for sub-types declarations
all : improved completion with lambda function
as3 : several generation fixes
all : bugfix haxe.rtti.Generic on private class
php/js/cpp : sanitize binary expressions to prevent inlining errors
spod : remove object from cache when deleted
2009-07-26: 2.04
flash9 : fixed get_full_path error with -D fdb
js : fixed Array.remove on IE
flash8 : removed extra empty AS3 tag (causing some issue with F8 loadMovie)
improved speed of Bytes unserializing (no need for BytesBuffer)
flash9 : bugfix, Null was generating dynamic code
flash9 : added error message in flash.Vector if used without flash 10
flash9 : fixed some "never" property access issues
all : added "never" property access support for all platforms
js : small syntax fix with value-blocks
js : fixed Type.enumEq with null values
js/flash8 : use &0xFF in haxe.io.Bytes.set
flash9 : fixed switch on Null verify error
flash9 : fixes related to UInt type + error when using Int/UInt comparison
as3 : improved Vector support, inline flash.Lib.as
as3 : bugfix with skip_constructor
as3 : added Enum.__constructs__ (allow Type.getEnumConstructs)
as3 : make all constructor parameters optional (allow Type.createEmptyInstance)
as3 : bugfix with property access inside setter (stack overflow)
all : Enum is now Enum
all : added Type.createEnumIndex
all : forbid same name for static+instance field (not supported on several platforms)
all : renamed haxe.Http.request to "requestUrl"
all : renamed neko.zip.Compress/Uncompress.run to "execute"
spod : fix very rare issue with relations and transactions
compiler : added TClosure - optimize closure creation and ease code generation
cpp : added CPP platform
all : added 'using' syntax
neko : added 'domains' optional param to ThreadRemotingServer to answer policy-file-request
php : fixed php.db.Mysql so that getResult is consistent with Neko behavior
php : fixed __toString for anonymouse objects
php : fixed bug in overridden dynamic functions
php : fixed round to be consistent with other platforms
php : fixed bug concatenating two dynamic variables
php : php.Lib.rethrow now works as expected
flash9 : fixed bug with SWC output and recursive types
flash8 : fixed inversed arguments in __new__
neko : added neko.net.Socket.setFastSend
php: fixed String.charCodeAt
php: minor optimization (removed foreach from std code)
php: implemented haxe.Stack
php: changed exception handler to use Haxe call stack
php: changed special vars to use the '\xBB' prefix instead of __
php: fixed use of reserved keywords for var names
php: List iterator is now class based (faster)
php: fixed behavior of class variables having assigned functions
php: fixed php.db.Manager (was uncorrectly removing superclass fields)
php: added support for native Iterator and IteratorAggregate interfaces
all : added --display classes and --display keywords
all : fixed issue with optional parameters in inline functions
all : allow implementing interfaces with inline methods
all : enable inlining for getter/setter/iterator/resolve/using
2009-03-22: 2.03
optimized Type.enumEq : use index instead of tag comparison for neko/flash9/php
bugfix for flash.display.BitmapDataChannel and GraphicsPathCommand (allow inline static)
resolve environment variable in -cmd commands
added flash.Vector.indexOf and lastIndexOf
fixed bug in interfaces that define the method toString (Haxe/PHP)
fixed bug in haxe.io.BytesInput.readBytes in Flash9 (was throwing Eof if full buffer can't be readed)
fixed implements/extends special classes when they are imported
StringBuf now uses an array for JS implementation (around same on FF, faster on IE)
fixed assignment of field length in anonym objects (Haxe/PHP)
fixed addEventListener typing for flash9
fixed __vector__ generation for AS3 target
fix with inline functions : position is now the inserted position and not the original one (better error reporting)
added SWC output support
fixed issues with unset of values in for loops and executing blocks that return functions (Haxe/PHP)
"throw" type is now Unknown instead of Dynamic (prevent type-hole in "if A else if B else throw")
added __foreach__ for flash9/as3
fixed f9 verify error with different kind of functions
moved eof() from neko.io.FileOutput to FileInput
added haxe.rtti.HtmlEditor
added neko.db.Manager.setLockMode
genAS3 : fixed Error classes issues
genAS3 : fixed default basic type value in interfaces
flash9 : fixed UInt default parameter verify error
flash9 : fixed issue with flash.* string enums verify error
compiler : allowed \r line separators for HXML files
flash9 : fixed verify error with loop variable beeing a specific class
compiler : prevent truncating float dynamic values to int when using numerical operations
neko.db.Manager fix : synchronize fields after locking an unlocked cached object
compiler : fixed issue with cascading inline+haxe.rtti.Generic
optimizer : reduce constant int/float/bool expressions and immediate function calls
flash9/as3/php : don't add Boot.skip_constructor test if no side effects in constructor
compiler : added --no-opt to disable expr reduction
compiler : separated basic and advanced commandline options
compiler : fixed printing of sub-function types
genHX : fixed generation of classes that extends another class (shouldn't be turned into enums)
speedup Array.remove on flash9/js
2008-11-23: 2.02
Std.is(MyInterface, Class) now returns true (Haxe/PHP)
php arrays are wrapped into _hx_array instances, fixes issues with references (array cast, access out of bounds ...)
removed untested php classes (php.DBase, php.IniHash)
added -D use_rtti_doc
flash.Lib.getTimer() now returns Int and is inlined
fixed php.FileSystem.stat
added memory related functions to php.Sys
added error when trying to extend Array, String, Date and Xml
fixed handling of implements ArrayAccess
fixed some minor things in flash10 api
switch/for/while/do/try/if are no longer using parse_next (parenthesises requ. instead)
fixed Type.typeof and Std.is in case of too much large integers for Flash6-8/JS
haxe.xml.Check : treat comments the same as PCDATA spaces
haxe.io.BytesData now uses strings instead of arrays for PHP
compiler : optimized line calculus from ast position
lexer : allow identifiers starting with _[0-9]
fixed access to flash.Vector methods : use AS3 namespace (faster)
bugfix in inline functions : modifying a parameter can't modify a real local var anymore
bugfix in inline functions : handle class type parameters and method type parameters
fixed issue with Int default value for Float parameter
flash9 : bugfix when using the retval after setting a closure variable
added flash.Memory API for flash10 alchemy opcodes access
changed #if as3gen to #if as3 when generating as3 code
fixed as3 flash.Vector generation
fixed haxe.io.BytesOutput for flash9 : set default to little-endian
some flash9 fixes related to extern enums
updated flash.text.engine package with haxe enums
flash9 : use target file path for Boot unique ID instead of random number
as3 : fixed bug when anonymous field was a reserved identifier
flash9 : added flash.Lib.vectorOfArray and vectorConvert for flash10
added -D check-js-packages to allow several haxe-generated js files in same page
2008-10-04: 2.01
fixed php.Sys
added neko.NativeString and neko.NativeArray
fixed php.Boot.__string_rec() when invoked from toString
fixed null references in class constructors for array arguments
fixed Type.enumParameters() and Type.typeOf() for PHP
fixed SPOD/MySql for PHP
fixed php.net.Socket.setTimeout(), php.io.Process
fixed php.Web.setCookie() for expire time
fixed php rethrow in catches and added the possibility to catch native exceptions
added runttime check for php.io.Socket.shutdown (uses fclose in php 5.1.x)
allowed optional Context in remoting connections
fixed extern classes for flash < 8
fixed inherited protected/private properties in as3 SWF library
fixed haxe.io float/double in Neko (when bigEndian was null)
added __FSCommand2__ support
optimized haxe.Unserializer (use faster buffer access)
use "Dynamic" instead of Dynamic->Void for flash9 IEventDispatcher
always use full classes paths for genAS3
prevent different get/set property accesses when implementing an interface
fixed assign of dynamicfunction references in PHP
Haxe/PHP now generates code for extern classes __init__
added strings literal support in haxe.Template
fixed Process arguments and exitCode() in Haxe/PHP
fixed hierarchy problem for classes with the name from different packages Haxe/PHP
php.db.Mysql now throws an exception when tries to connect to an unexistant DB
fixed blocks in if statements for Haxe/PHP
added php check on the full hierarchy for colliding names
added support for "g" modifier in EReg for PHP
PHP now generates __toString for classes that have toString defined
implemented php.Lib.getClasses()
fixed duplicate fields in Type.getInstanceFields on subclass
Enum is no longer defined inside Type but is standalone class
fixed Date.getDay on Neko/Windows (use %w instead of %u)
fixed memory leak with PHP closures
fixed wrong scope in PHP closures
fixed Array.reverse() in PHP
fixed Reflect.compareMethods in Neko (require Neko 1.8.0)
fixed flash7-8 register usage for __init__ and static variables initialization
moved StringTools.baseEncode/Decode to haxe.BaseCode
fixed binary resources for Flash, JS and PHP outputs
fixed compiler bug with inline + optional arguments
fixed Type.createInstance and createEmptyInstance with Array for flash6-8
2008-07-28: 2.0
fixed current package bug in inherited constructor type
delayed type-parameter constraints check (allow mutual rec extends for SPOD)
improved unclosed macro error reporting
Haxe/PHP integration
renamed NekoSocketConnection to SyncSocketConnection (php support)
fixes in genAs3
fix for flash9 : always coerce call return type
set all private+protected names from SWF lib to public (allow override+reflect)
flash9 : use findprop instead of findpropstrict for 'this' access (allow dynamic)
don't allow nullness changes in overrided/implemented
prevent typing hole with overriden polymorphic methods
added neko.vm.Mutex and neko.vm.Deque (included in neko 1.7.1)
added package remapping using --remap
2008-07-17: 2.0-RC1
genneko : remove big array error (fixed in neko 1.7.1)
fixed neko.net.ThreadRemotingServer.onXML
genswf9 : fixed verify error with Null (was using dynamic access)
small patch for jsfl support
added .cca for faster string operations on Flash9/Flash/JS
bugfix with inlined local variables
upgraded flash9 api to flex3/player 9.0.115
override is now mandatory, no more --override
dynamic is now a keyword
f9dynamic is now dynamic and is mandatory on all platforms
public/private/dynamic are inherited by default when overriding a method
removed Reflect.empty() : use {} instead
changed #else by #elseif, added #else
flash9 : optimized Hash,IntHash,StringBuf (use typed value)
Reflect.field/setField/callMethod , Type.enumIndex and StringBuf methods are now inlined
optimized haxe.Md5 : don't use statics
allow up to 8 parameters in Reflect.createInstance
flash9 : some minor optimizations in haxe.Serializer
added haxe.io package (removed things from neko.io)
__resolve becomes resolve (and should be documented)
added haxe.Int32
removed neko.Int32
removed neko.io.Input/Output/Eof/Error/Logger/Multiple/StringInput/StringOutput
removed neko.net.RemotingServer
changed neko apis to use haxe.io and Bytes instead of String buffers
fixed big bug in js/flash8 debug stack handling
complete rewrite of haxe.remoting package
haxe.io.Bytes serialization support (replace deprecated string support)
removed === and !==
removed Std.bool
fixed : Reflect.field(null) in flash9 doesn't throw an error anymore
removed Type.toClass and Type.toEnum
Dynamic type is now a class and not an enum
moved reflection support for core types from Boot to Std
fixed Type.getClassName/getEnumName/resolve for core flash9 types
renamed haxe.rtti.Type to haxe.rtti.CType (with changes in prefix)
added haxe.TimerQueue, added haxe.Timer.delay, remove haxe.Timer.delayed
flash9 : bugfix, generated interfaces were empty
fixed bug while writing block-vars in flash/js
added parameters default value (constants)
removed Std.resource, Std.ord, Std.chr
added haxe.Resource, allow binary data in resources
added Type.createEnum
check that local variables get correctly initialized before usage
haxe.Stack support for flash9
2008-04-05: 1.19
fixed flash9 Array.toString
fixed inline return bug
added haxe.rtti.Generic behavior
added haxe.FastList
bugfix to prevent recursive anonymous
fixed some incorrectly reported "recursive inline" errors
fixes in genas3 + genswf9 for Dynamic/* in methods
{} is now an empty object and not an empty block
fixed some verify errors left in flash9
fixed private/protected differences in gen-hx-classes
genswf9 : allowed to store a Class in a typed register
fixed switch-on-bool (don't use matching)
genswf9 : optimized switch on ints
some renames in haxe.rtti.Type
added flash.utils.TypedDictionary for F9
genswf9 : fixe debug filename with inline code
fixed completion for packages starting with 'a' or 'z'
added flash9.Lib.as
prevent double Movieclip class declaration when linking flash9 lib
allow numerical operations on type parameters constraint by Float
genswf9 : fixed dynamic inheritance
2008-02-23: 1.18
some optimization and bugfix for as3 codegen
bugfix : allow bitmaps and fonts classes for F9 library
bugfix : neko.Web.setCookie
bugfix : as3 switches in -swf-lib, and enable to "repair" corrupted as3 bytecode
fixed --i return value in flash9
fixed some transforms in flash9
added js.Selection
simplified js.Dom (more events)
added haxe.xml.Fast.innerHTML
added Reflect.compare
fixed "".split() in Neko (now returns [""] instead of [])
bugfix for swf-lib f9 classes ordering
added EReg.customReplace
added neko.Lib.lazyLoad and improved neko.net.Poll for Neko 1.6.1
prevented static fields in interfaces
added neko.Sys.cpuTime()
fix for protected as3 classes
added support for flash9 XML (in flash.xml package)
added neko.vm.Tls for Neko 1.6.1
added --no-inline
renamed neko.zip.File to neko.zip.Reader
added neko.zip.Writer and neko.zip.CRC32
fixed multilevel Transform.block_vars
added js.SWFObject
fixes for if/switch with null or Null on Flash9
2008-01-13: 1.17
fixed Int32.compare, added Int32.read and Int32.write
fixed type of unitialized registers in flash9
fixed Sqlite transactions (commit and rollback now restart a transaction)
several flash9 optimizations
flash9 debug support (with -D fdb)
set align to TopLeft if not defined for flash9
added neko.vm.Gc
fixed Null should not be a value
bugfix in serialization format with USE_ENUM_INDEXES
added apis in DateTools for time manipulation
bugfix in flash9 : strictly typed local vars used in local functions
always force swf version and sandbox redefinition
added as3hl layer
merge as3 classes
use flash9 fast switch for enums
always use match for enums (no switch even if constant)
fixed DateTools.format %I and %l in Flash/JS
securized Hash for JS and Flash
compiletime F9 class generation for F8 swflib
optimized for loops (Array and IntIter)
added #line support
more f9 Null support for "if" and array declarations
more neko.Web.setCookie parameters
added "inline" for methods and static vars
fixed % type in flash9
2007-10-31: 1.16
use _sans font for default flash traces (better Linux support)
fixed haxe.remoting.Connection compilation for Flash<8
added fix to prevent 64K identifiers limit on Flash<9
ensure order of anonymous fields initialization
fixed haxe.remoting.Connection.urlConnect in JS
use amortized O(1) for Neko Array implementation
ndlls libraries should now use .neko() instead of __a
allowed 'u' utf8 for regexp (needs Neko 1.6.1 regexp.ndll on windows)
onclick and onsubmit JS events returns Bool
fixed inherited constructor of extern class was always private
fixed Ereg.split without 'g' flag on JS/Flash9
fixed haxe.Stack in JS without -debug
added support for -D no-swf-compress
fixed ByteArray.readObject
fixed implements Dynamic in Flash9
removed neko.io.FileInput.eof, fixed neko.io.Input.readLine
fixed haxe.Template for Flash9
added neko.Sys.command optional array of arguments
removed haxe.Proxy
added flash.XMLRequest
fixed Type.enumParameters for Neko
guaranteed order of Type.getEnumConstructs same as code
used index-based dispatch for enums
added Type.enumIndex
fixed enum.toString for Flash and JS
support for -Dnetwork-sandbox
trim -cp and -resource
various genas3 fixes
2007-08-29: 1.15
fixed bug with Enum.construct when Enum have type parameters
change with "untyped" : arguments types are checked (because of opt select)
haxedoc : fixed type parameters display
fix for JS and Flash9 XML parser : allow newlines in attributes
disable Flash9 resources with AS3Gen
error on extra anonymous fields
error on too much big neko array declaration (neko 1.6 max_stack limit)
fixed Flash9 statics slots (FP 9,0,60 compatibility)
fixed Flash9 Type.getClassName
optional enums arguments on Flash9 are now automatically Null
forbid usage of type parameters in static functions
fixed Std.int with negative numbers
fixed some F9 issues with Haxe-specific Array, Date and Math methods
used AS3 namespace for F9 Array and String instance methods
fixed F9 with uninitialized integer registers
fixed F9 + operator with Dynamic/Null operands
added Enum subtyping
fix with remoting threadserver and exceptions
fixed Flash9 dynamic runtime type field access
fixed very tricky typing bug with constructors inheritance
fixed some documentation related parser bug
fixed stack overflow with static setter
fixed package completion bug when -cp points to an not existing dir
fix duplicate sandboxes tags with -swf
__resolve in Haxe Remoting is now public
2007-07-25: 1.14
fixed no error when invalid "catch" expression
remove variance
fixed prototype bug in neko when "Main" class is defined
fixed flash9 xml iterator methods
bugfix in flash9 ByteArray serialization
fixed genAS3 conflicting classes and interfaces
preserve neko output file extension
added flash.Event for Flash9
added --no-output
fixed neko.net.Socket peer and host methods
added neko.io.Process and neko.vm.Ui
added haxe.xml.Proxy
some flash6 fixes
allowed simplequotes for xml attributes in Flash9 and JS
flash9 optimizing compiler
new faster neko binary AST
added haxe.remoting.NekoSocketConnection and SocketProtocol
don't allow for...in iteration with Dynamic or Unknown
added flash9 resources
fixed precedence of ternary operator ?:
2007-05-18: 1.13
fixed bug with local variable masking package in catch type
fixed "Not_found" when enum params differs
added "override" for AS3 generator
fixed stack overflow in typedefs
added haxe.Timer.queue, removed delayedArg (use callback instead)
fixed haxe.remoting.SocketConnection (msg invertions might occur)
add uniqueness check for switch constants
js : HtmlCollection and MetaDom.childNodes are not true Arrays
allowed semicolon after typedef declaration
fixed in-loop closure usage of "for" variable for Flash and JS
added neko.net.ThreadRemotingServer.onXml (to handle crossdomain xml)
more accurate stack trace for socket remoting
prevent some memory leak in haxe.Timer / JS
added flash fullscreen support
added cond?a:b syntax support
added utf8 buffer api
added haxelib "dev" mode
renamed Http.asyncRequest to customRequest
add classes to Neko module export table
fixed parametrized enums for Flash6
fixed bug with completion and interfaces
fixed --flash-use-stage in Flash9
2007-03-06: 1.12
added flash lite support with -D flash_lite
bugfix for Unknown should Unknown
prevent some exceptions in neko.net.ProxyDetect
fixed ByteArray serialization
added neko.Int32
added -x for fast neko scripting
prevent locals from breaking class access (works with imports)
fix in function overriding subtyping
added haxe.remoting.FlashJsConnection
fixed tar support in neko.zip.File
ide completion support using --display
give access to neko.net.Host ip (as Int32)
fixed bug when calling super.UpperCaseMethod()
hide additional flash Array methods
allow leading comma in anonymous types
added haxe.Public interface
added AS3 code generator
field lookup gives priority to superclass over interfaces
improved haxedoc output
fixed bug in neko regexp split/replace when empty match at eol
fixed bug in flash 6-7-8 resources generation
2007-01-28: 1.11
changed StringBuf.add implementation
added haxe.Firebug
allowed variable return type for overriden/implemented methods
display error position in front of each error line
improved error messages when optional arguments not matched
added neko.io.Path
added neko.net.ProxyDetect
bugfix in unify : prevent recursive anonymous objects
haxe.Http call "prepare" only if size is known
added multiple expressions in "case"
serialization : deprecated old string format, use urlEncode/Decode
added flash9 bytearray serialization (to binary string, for neko com)
fixed Type.typeof on some flash9 instances
no more dontUseCache (haxe.Serializer.USE_CACHE, default to false)
small genxml/haxedoc improvements
added Type.enumEq
local function parameters are now inferred in several cases
optional RTTI for Spod Object
bugfix related to callback in neko code generator
more type error stack (now includes type parameters)
type system fixes in anonymous subtyping
added Iterable, changed Lambda
added TAR and GZIP support to neko.io.Zip
compute minimal array content type
fixes in enum switchs
2007-01-01: 1.10
fix in haxe.remoting.SocketConnection.readAnswer
fix in postfix incr/decr and getter/setter
added haxe.Http.fileTransfert for Neko
fixed haxelib to 1.02 (use multipart file transfert)
fixed Array.reverse
added flash.Lib.getURL and fscommand for Flash9
fixed some ignored parse errors
fixed minor syntax : immediate object access
allow extend/implements a typedef
fixed Flash9 AMF remoting
fixed Flash9 bugs in Date object
fixed dynamic Array typing bug
allowed typedef private field access
added Class base class type
AsyncConnection.call callback is now optional
fixed if/switch with no else/default compilation
moved Reflect.createInstance to Type
added Reflect.makeVarArgs
haXelib 1.03 : several developers per project + web interface
2006-11-22: 1.09
added neko.vm.Module and neko.vm.Loader
haxelib : allowed spaces in "run" arguments
allowed Thread comparison
fixed bug in SWF6 compilation
allowed either Mysql or Mysql5 usage
replaced db.Connection.hasFeature by db.Connection.dbName
added Socket.custom field
moved neko.Thread to neko.vm.Thread
define haxe_109 (for api changes)
fixes in haxe.remoting.Connection and haxe.Unserializer for F9
added haxe.remoting.Connection.urlConnect for JS
allowed private typedef fields
added neko.net.ThreadServer, ThreadRemotingServer and Poll
removed neko.net.RemotingBuffer
relaxed enums switchs (allow value in first case)
changed "cast" codegeneration (fix some F9 usages)
change in POST data handling in mod_neko (max 256K, except multipart)
added neko.Web.getClientHeaders and neko.Web.flush
"callback" is now a keyword
fixed stack overflow when typedef = Dynamic
fixed Reflect.createInstance on F9
Array : slice optional length, fixed neko slice & splice
+ fixed cast return type
2006-10-29: 1.08
fixed bug in flash -debug
fixed Sqlite result .length
fixed missing "." in OSX/Linux default classpath
fixed haxelib NDLL autoloading on OSX
fixed bug in deserialization of "\\\r" sequence
added inheritance and fields getter/setter to xml output
haxedoc 2.0
fixed neko native enum serialization
fixed "all constructors matched" for enums without params
fixed returned value semantics in neko (prevent remoting leak)
more documentation
added haxe.rtti package (classes can implement haxe.rtti.Infos)
fixed windows line endings in exclude files under linux/osx
fixed small bug in "cast" syntax
added "callback" for partial function application
added --auto-xml for future haxeFD usage
fixed Reflect.isFunction
minor bugfix in JS code generator
new neko.net package
allow recursive remoting proxys (skip instead of error)
added neko.Thread and neko.Lock MultiThread classes
added neko.net.ServerLoop for multiple clients handling
2006-09-11: 1.07
fixed resources in Neko
typedef, override, package and f9dynamic are now keywords
slighly changed error format output
fixed "undefined" serialization and Type.typeof
some fixes in haxelib
set default classpath for non windows systems
added variance
fixed bug in bounded type parameters
fixed scope bug in try/catch with Flash9
added remoting over XMLSocket and LocalConnection for Flash9
fixed Std.is(*,null) = false
allowed >64K Haxe/neko strings
-debug and stack traces support for Flash and JS
minor changes in xml output
2006-08-28: 1.06
allowed extern enums
use only matching construct when parameters are matched
fixed bug preventing & char to be sent between JS and Flash remoting
improved flash9 api (more strict)
flash9 xml : use JS ReXml parser
added neko.io package (Input/Output)
moved neko.File and neko.Socket to neko.io package
fixed flash optional arguments (when extending flash.MC)
fixed neko native serialization problems
variable modification does not have side effects in 'for x in a...b'
jit disabled by default for neko web server
enable flash7-8 libraries usage from flash9
unknown identifier become "class not found" when representing a classpath
changed haxe.PosInfos handling
added -debug (removed --flash-debug) effective on flash9 and neko only now
added Type.typeof
improved Serializer speed
added Serialization support for Date, Hash, IntHash, List
added flash9 and JS IE/Opera class reflection
added haxe.xml.Check and haxe.xml.Fast
added Xml.parent
added haxelib
added ArrayAccess interface
2006-08-16: 1.05
moved Md5 to haxe package.
some method renamed in neko.FileSystem.
added neko.remoting.Server.setLogger
fixed bug in haxe.Serializer on neko (was preventing List serialization)
fixed bugs in Haxe.Unserializer on neko (invalid enum tag & pbs with UTF8 strings)
fixed sqlite escape & quote , added BOOL support
allowed direct property access in getter/setter (prevent rec loop)
allowed event-driven neko http requests
forbidden "name" static in js
don't allow variable redeclaration in subclasses
added && || and ! in conditional compilation rules
metas : removed __construct__ and class.toString.
metas : __super__ and __interfaces__ now optional
added Type api (seperated from Reflect)
flash 9 support
2006-07-25: 1.04
added macros in haxe.Template
allowed static variables access from a signature shortcut
allowed new Signature when signature is a class
fixed : modulo priority is now higher than mult and div
fixed bug in haxe.Proxy generation
fixed more stack overflows with recursive signatures
fixed bug in class <: anonymous subtyping (inherited fields)
override is not mandatory by default (need --override)
added neko just-in-time
fixed bugs in haxe.Serializer and haxe.Unserializer (enum format change)
changed "signature" by "typedef" (more comprehensible)
restricted objects comparisons
fixed bug with js operator priority
improved performances for haxe.Serializer and haxe.Unserializer
fixed bug in static variable lookup (should look class in the last case)
prevented several prints of "not enough arguments".
2006-06-23: 1.03
haxedoc executable now part of the distribution
removed selectDB from the neko.db.Connection API
added optional parameters with selection
removed --no-flash-opt-args
changes in SWF packages handling
fixed optional leading comma in anonymous object and array values
fixed bug in inheritend constructor type parameters
fixed bug in type_field with inherited type parameters
added haxe.Proxy
added code transformations for swf/js block variables
fixed very tricky bug with constraint parameters used together with polymorphic methods
added selective import (import x.y.Class.InnerType)
added optional enum constructor parameters
added opened anonymous types (no more Unknown has no field...)
fixed "MovieClip extends flash.MovieClip".
added Reflect.copy
added neko.Random
added Date.fromString
fixed bug in haxe.Unserializer, slighlty optimized haxe.Serializer
added __setfield magic (complete __resolve)
added explicit override when overriding methods
2006-06-08: 1.02
fixed stack overflow when recursive class <: recursive signature
improved a bit commandline : allow several hxml arguments
added {> Class, fields... } types declarations
added cast without type (less dangerous than untyped)
no stage objects by default, added --flash-use-stage
added haxe.remoting.DelayedConnection
added -exclude
removed classpath from neko debug infos filenames
fixed bug in Neko empty Array.pop and Neko EReg.replace ""
fixed nodeValue for Neko XML comments, doctype, prolog
improved DocView : formating, signatures, files generation
added neko.zip package
fixed bug in neko.File binary flags
fixed problems when downloading large files using haxe.Http under Neko
neko.db.Connection and neko.db.ResultSet are now interfaces
added neko.db.Sqlite and neko sqlite ndll
mod_neko2.ndll for Apache2 in Windows distribution
fixed bug in static properties method resolution
change js.Dom : use cascading signatures and improved api
added haxe.unit Unit test framework
2006-05-25: 1.01
added neko.Utf8
Serializer/Unserializer now support utf8 strings
allowed subtyping of prop accesses public/private when implementing an interface
removed "eval" from Remoting APIs (only calls - more easy to handle).
added flash6 support
fixed Std.is on different platforms (interfaces implements interface)
added AsyncConnection.amfConnect for flash
added SWF overflow checks
changed "property" to "var"
don't allow monorph unification with Dynamic (more safe)
allowed multiple parsing and typing errors
review and completed commandline options
error on backwards constant integer iterators
remoting proxy constructor is now public
fixed -swf-header override the swflib background color
moved all remoting classes into the haxe.remoting package
added haxe.remoting.LocalConnection
2006-05-17: 1.0
fixed small bugs in JS Xml Parser (empty attribute, newlines in attributes)
added default Content-Type for haxe.Http in JS
haxe.AsyncConnection : onError should not be call if error occur in onData
fixed infinite loop if haxe.Unserializer.readDigits reach eof on JS/Flash
fixed bugs in neko.Web and neko.Sys (some methods returning "null" instead of null)
added neko.Socket.setBlocking for nonblocking sockets
fixed bug in js generator when using cascading iterators
fixed typing bug when overloading parametrized method
fixed bug in js generator when "try" without curly braces.
allowed enum catching
added remoting proxys
allowed neko.Web API commandline emulation outside mod_neko
removed subtyping Anon :> Instance
added signatures, Iterator is now a signature
getter/setter and public/private unification
allowed anonymous declaration with interface-style syntax (for signatures)
optimized code generated for underscore in enum matches parameters
fixed flash/js String.charCodeAt(outside) => null
fixed neko charAt(outside) => ""
added errors for strings containing \0 in JS and Flash
added HAXE_LIBRARY_PATH environment variable support
fixed interfaces inheritance : can't extend, can implement (type-sums)
fixed fixed >64K resource bug in SWF
fixed newline problems with Flash/JS Connection
2006-05-02: RC1
added the Socket class
fixed a bug of returned value in neko with 6 or more parameters
added "Missing type" error for catchs.
added regular expressions (still missing Flash implementation)
fixed type printing and parenthesis in type declarations
different behavior when elements removed during Array.iteration
fixed genswf : local variables used in for...function
improved type parameters structure coherency
enable usage of Spod without Transaction
implemented neko.db.Transaction.isDeadlock
slighly relaxed one of the javascript generator constraint
added haxe.Template
moved Log , PosInfos and ImportAll to haxe package
completed private class/interface/enum support
removed Array.indexes
added __resolve compile-time support when class implement Dynamic
added haxe Remoting
added "module with different case" error (for windows)
added Reflect.resolveClass, Reflect.resolveEnum, Reflect.setPrototype
added access to classes by name in genneko
added enum.__ename__
fixed Std.is(e,enum)
fixed infinite loop in neko EReg split/replace and epsilon matching
added neko native serialization support
fixed syntax for multiple constraints in type parameter
added recursive type parameters contraints (T : C constraints)
updated Xml handling
2006-04-17: beta 5
fixed bug : continue in do...while
changed typing order for do...while (infer condition after block)
fixed JS "catch" generation
fixed extending flash.* extern class
fixed bug in neko generator w/ closures
fixed bug in js generator (return switch need correct "this" context)
fixed bug in for x in a...b : invalid local variables overridding
added properties
fixed bug in js generator : while...switch...break
new List implementation
can use static function __init__ on every platform
bug fixes in Reflect.fields
added Hash.remove, changed Hash/JS implementation
added flash __delete__ support
added neko.db.Object, Manager, Transaction
fixed neko class.__interfaces__
added "assigning a value to itself" error
added automatic PosInfos when is last parameter
added polymorphic methods
added check_flash_args support
2006-04-02: beta 4
fixed javascript events case
fixed invalid use of physeq
fixed + type inference
added -altfmt
allowed anonymous <: class subtyping
relaxed unifications of expressions in "for" and "while"
more methods in List
syntax changes : mandatory parenthesis for "for" and "while"
allowed any kind of identifier almost everywhere
moved tools, flash, js and neko inside "std"
no need for 0x in flash header bgcolor
added -res
fixed type parameter contraint holes
Std.is Dynamic always returns true
added Enum.toString
neko : env locals can be modified in inner functions
completed js keywords list in generator
added Reflect.typeof
prioritize neko.Lib.load static calls
fixed bugs in for...in optimization with continue
fixed Reflect fields, added documentation, added Class
added javascript closures, fixed null closures on flash and Neko
added javascript __init__ statics and js.XMLHttpRequest
added neko.Stack
fixed bug in Std.ord
convert neko string to haxe string on catch
automaticaly creates empty clips for classes extending flash.MovieClip
unify stack : several meaningful unification errors
added cast operation and keyword
2006-03-11: beta 3
javascript generator
optimized for in interval
renaming of locals (name must be unique)
added uncaught exceptions handling in Flash
fixed Bool.true == true and Bool.false == false on all platforms
fixed matching on Bool different from enums
removed -fplayer (use -D instead) and added -fheader
fixed infinity is Int
added "here" special identifier
neko Apis : File, FileSystem, Sys
added base JS API
2006-02-19: beta 2
renamed neko.db.Result to neko.db.ResultSet
added Date support for Mysql results
added private fields for static class anonymous types
disambigous >=, >>= and >>>=
fixed inheritance bug in swf and neko generators
improved function parameters type error reporting.
allowed variable number of args for flash.* constructors.
added Math.random(), Reflect.empty()
added flash.XMLSocket and flash.Timer classes
completed Std class with conversion functions and others.
completed flash.Lib class with flash toplevel functions.
fixed bugs in neko webserver
2006-02-04: beta 1
allowed array literals to be dynamic
use neko 1.2 commandline and prototypes
changed #cond to #if cond for conditional compilation
all fields are defined to null by default
defined __class__ and other meta accesses for Flash and Neko
fixed type hole for compiler-know types (should not resolve using imports)
changed packages : neko.* and flash.* (with protection)
added Lazy types : type the fields when they are needed with recursion
untyped accesses are monomorphs, not dynamics
generated __string check that toString() return an object
XmlParser and other APIs for Neko
fixed escaped chars in Neko generation
conservative static initialization order
allowed no type parameters for new Class
function types carry parameter names
anonymous types contain private variables (for private static accesses)
added optional name for anonymous types in typer (for static accesses)
private classes and enums (partial support)
improved error message for invalid number of arguments
flash extern classes can take variable number of args.
added -swf-lib for importing SWF library
added neko.db package
2005-12-23: alpha 5
added -main commandline parameter
catches are now working with Neko
restricted catch types for type-safety
added constructor inheritance + check if superconstructor is called
allowed Dynamic-only subtyping on type parameters
added method closures to Neko generation
added class Reflect
added License : libraries are BSD
added -xml documentation output
allowed class instance :> anonymous subtyping
2005-12-10: alpha 4
forbid break and continue outside loops
fixed SWF generation bugs
added SWF "extends" support
added method closures
added some flash lowlevel operations (__xxx__)
added Log, LogInfos and trace
added Neko generation
fixed problems with conditional compilation macros
2005-11-30: alpha 3
added Flash extern classes
Boot initialization
added "untyped"
added conditional compilation
added interfaces
changed iterators from closures to objects
added (XML)Node and XmlParser for Flash
2005-11-25: alpha 2
swf generation (missing iterators)
some typing fixes
2005-11-17: alpha 1b
fix some bugs
changed package tests.lang
2005-11-14: alpha 1
lexer
parser
typer
haxe_3.2.1+dfsg.orig/extra/CONTRIB.txt 0000664 0001750 0001750 00000005133 12607337712 017312 0 ustar andy andy 0000000 0000000 Contributor License Agreement :
You accept and agree to the following terms and conditions for Your present and future Contributions submitted to the project Haxe :
1) Definitions
"Contribution" : any source code, documentation, including any modifications or additions to an existing work that is intentionally submitted by You to the Haxe Foundation for inclusion in, or documentation of, any of the products managed and maintained by the Haxe Foundation.
"Submitted" means any form or electronic, verbal or written communication, including but not limited to communication on electronic mailing lists, source code control systems and issue tracking system that are managed by, or on behalf of, the Haxe Foundation for the purpose of improving Haxe.
2) Grant of Copyright License. Subject to the terms and conditions of this Grant, You hereby grant to the Haxe Foundation and to recipients of software distributed by the Haxe Foundation a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute Your Contributions and such derivative works.
3) You represent that you are legally entitled to grant the above license. If your employer(s) has rights to intellectual property that you create that includes your Contributions, you represent that you have received permission to make Contributions on behalf of that employer, that your employer has waived such rights for your Contributions to the Haxe Foundation, or that your employer has executed a separate Corporate Contributor License Grant with the Haxe Foundation.
4) You represent that each of Your Contributions is Your original creation (see section 7 for submissions on behalf of others). You represent that Your Contribution submissions include complete details of any third-party license or other restriction (including, but not limited to, related patents and trademarks) of which you are personally aware and which are associated with any part of Your Contributions.
5) You are not expected to provide support for Your Contributions, except to the extent You desire to provide support. You may provide support for free, for a fee, or not at all. Unless required by applicable law or agreed to in writing, You provide Your Contributions on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON- INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE.
Full Name :
Email :
Mailing Address :
Country :
Signature: haxe_3.2.1+dfsg.orig/extra/EnvVarUpdate.nsh 0000664 0001750 0001750 00000024101 12607337712 020523 0 ustar andy andy 0000000 0000000 /**
* EnvVarUpdate.nsh
* : Environmental Variables: append, prepend, and remove entries
*
* WARNING: If you use StrFunc.nsh header then include it before this file
* with all required definitions. This is to avoid conflicts
*
* Usage:
* ${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
*
* Credits:
* Version 1.0
* * Cal Turney (turnec2)
* * Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this
* function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar,
* WriteEnvStr, and un.DeleteEnvStr
* * Diego Pedroso (deguix) for StrTok
* * Kevin English (kenglish_hi) for StrContains
* * Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry
* (dandaman32) for StrReplace
*
* Version 1.1 (compatibility with StrFunc.nsh)
* * techtonik
*
* http://nsis.sourceforge.net/Environmental_Variables:_append%2C_prepend%2C_and_remove_entries
*
*/
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"
!include "StrFunc.nsh"
; ---- Fix for conflict if StrFunc.nsh is already includes in main file -----------------------
!macro _IncludeStrFunction StrFuncName
!ifndef ${StrFuncName}_INCLUDED
${${StrFuncName}}
!endif
!ifndef Un${StrFuncName}_INCLUDED
${Un${StrFuncName}}
!endif
!define un.${StrFuncName} "${Un${StrFuncName}}"
!macroend
!insertmacro _IncludeStrFunction StrTok
!insertmacro _IncludeStrFunction StrStr
!insertmacro _IncludeStrFunction StrRep
; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'
!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'
; ---------------------------------- Macro Definitions end-------------------------------------
;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'
!macro EnvVarUpdate UN
Function ${UN}EnvVarUpdate
Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0
/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */
; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}
; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}
${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}
; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}
; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}
; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${${UN}StrStr} $7 $0 " ;"
${If} $7 == ""
${ExitDo}
${EndIf}
${${UN}StrRep} $0 $0 " ;" ";" ; Remove ';'
${Loop}
${Do}
${${UN}StrStr} $7 $0 "; "
${If} $7 == ""
${ExitDo}
${EndIf}
${${UN}StrRep} $0 $0 "; " ";" ; Remove ';'
${Loop}
${Do}
${${UN}StrStr} $7 $0 ";;"
${If} $7 == ""
${ExitDo}
${EndIf}
${${UN}StrRep} $0 $0 ";;" ";"
${Loop}
; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';' to ''
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';' to ''
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}
/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */
${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0
${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter
${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;
; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;
IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}
; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}
; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
${EndIf}
IfErrors 0 +4
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
Goto EnvVarUpdate_Restore_Vars
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0
FunctionEnd
!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------
!verbose pop
!endif
haxe_3.2.1+dfsg.orig/extra/ImportAll.hx 0000664 0001750 0001750 00000007334 12607337712 017722 0 ustar andy andy 0000000 0000000 /*
* Copyright (c) 2005, The Haxe Project Contributors
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT 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 HAXE PROJECT 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.
*/
import haxe.macro.Context;
class ImportAll {
public static function run( ?pack ) {
if( pack == null ) {
pack = "";
haxe.macro.Compiler.define("doc_gen");
}
switch( pack ) {
case "php":
if( !Context.defined("php") ) return;
case "neko":
if( !Context.defined("neko") ) return;
case "js":
if( !Context.defined("js") ) return;
case "cpp":
if( !Context.defined("cpp") ) return;
case "flash":
if( !Context.defined("flash9") ) return;
case "sys":
if( !Context.defined("neko") && !Context.defined("php") && !Context.defined("cpp") ) return;
case "java":
if( !Context.defined("java") ) return;
case "cs":
if( !Context.defined("cs") ) return;
case "python":
if( !Context.defined("python") ) return;
case "tools":
return;
case "build-tool":
return;
}
for( p in Context.getClassPath() ) {
if( p == "/" )
continue;
// skip if we have a classpath to haxe
if( pack.length == 0 && sys.FileSystem.exists(p+"std") )
continue;
var p = p + pack.split(".").join("/");
if( StringTools.endsWith(p,"/") )
p = p.substr(0,-1);
if( !sys.FileSystem.exists(p) || !sys.FileSystem.isDirectory(p) )
continue;
for( file in sys.FileSystem.readDirectory(p) ) {
if( file == ".svn" || file == "_std" )
continue;
var full = (pack == "") ? file : pack + "." + file;
if( StringTools.endsWith(file, ".hx") ) {
var cl = full.substr(0, full.length - 3);
switch( cl ) {
case "ImportAll", "neko.db.MacroManager": continue;
case "haxe.TimerQueue": if( Context.defined("neko") || Context.defined("php") || Context.defined("cpp") ) continue;
case "Sys": if( !(Context.defined("neko") || Context.defined("php") || Context.defined("cpp")) ) continue;
case "haxe.web.Request": if( !(Context.defined("neko") || Context.defined("php") || Context.defined("js")) ) continue;
case "haxe.macro.ExampleJSGenerator","haxe.macro.Context", "haxe.macro.Compiler": if( !Context.defined("neko") ) continue;
case "haxe.remoting.SocketWrapper": if( !Context.defined("flash") ) continue;
case "haxe.remoting.SyncSocketConnection": if( !(Context.defined("neko") || Context.defined("php") || Context.defined("cpp")) ) continue;
case "sys.db.Sqlite" | "sys.db.Mysql" | "cs.db.AdoNet": continue;
}
Context.getModule(cl);
} else if( sys.FileSystem.isDirectory(p + "/" + file) )
run(full);
}
}
}
}
haxe_3.2.1+dfsg.orig/extra/LICENSE.txt 0000664 0001750 0001750 00000117637 12607337712 017311 0 ustar andy andy 0000000 0000000 Haxe Licenses
-------------
For details about Haxe Licenses, please read http://haxe.org/doc/license
The MIT Licence :
--------------------------
Copyright (C)2005-2012 Haxe Foundation
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
The Haxe compiler GPL License :
-------------------------------
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
The Neko LGPL License :
-----------------------
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
haxe_3.2.1+dfsg.orig/extra/all.hxml 0000664 0001750 0001750 00000000667 12607337712 017122 0 ustar andy andy 0000000 0000000 --no-output
--macro ImportAll.run()
-D doc-gen
--each
-neko all.n
-xml neko.xml
--next
-js all.js
-xml js.xml
--next
-swf all9.swf
-xml flash9.xml
-swf-version 11.4
--next
-php all_php
-xml php.xml
--next
-cpp all_cpp
-xml cpp.xml
-D xmldoc
-D HXCPP_MULTI_THREADED
--next
-java all_java
-xml java.xml
-D xmldoc
--next
-cs all_cs
-D unsafe
-xml cs.xml
-D xmldoc
--next
-python all_python
-xml python.xml
--next
-xml cross.xml
haxe_3.2.1+dfsg.orig/extra/all.hxproj 0000664 0001750 0001750 00000003215 12607337712 017454 0 ustar andy andy 0000000 0000000 
haxe all.hxml
haxe_3.2.1+dfsg.orig/extra/clean-whitespace 0000775 0001750 0001750 00000000276 12607337712 020616 0 ustar andy andy 0000000 0000000 #!/bin/sh
#
# Remove trailing whitespace from Haxe files
# Exclude generated js.html.* for now
find -path ./std/js/html -prune -o -name '*.hx' -print0 | xargs -0 perl -pi -e "s/[ \t]+$//"
haxe_3.2.1+dfsg.orig/extra/extract.hxml 0000664 0001750 0001750 00000000167 12607337712 020017 0 ustar andy andy 0000000 0000000 -debug
-swf-lib library.swf
-swf test.swf
-swf-version 15
--macro patchTypes("../extra/extract.patch")
--gen-hx-classes haxe_3.2.1+dfsg.orig/extra/extract.patch 0000664 0001750 0001750 00000147304 12607337712 020153 0 ustar andy andy 0000000 0000000 // types patches configuration for playerglobal.swc
flash.display.DisplayObject.filters : Array;
-flash.accessibility.Accessibility.new
@:require(flash10_1) flash.accessibility.ISearchableText
@:require(flash10_1) flash.accessibility.ISimpleTextSelection
@:require(flash10_1) flash.automation.ActionGenerator
@:require(flash10_1) flash.automation.AutomationAction
@:require(flash10_1) flash.automation.Configuration
@:require(flash10_1) flash.automation.KeyboardAutomationAction
@:require(flash10_1) flash.automation.MouseAutomationAction
@:require(flash10_1) flash.automation.StageCapture
@:require(flash10_1) flash.automation.StageCaptureEvent
-flash.desktop.Clipboard.new
flash.desktop.Clipboard.formats : Array;
flash.desktop.Clipboard.$format : ClipboardFormats;
flash.desktop.Clipboard.$transferMode : ClipboardTransferMode;
enum flash.desktop.ClipboardFormats;
enum flash.desktop.ClipboardTransferMode;
enum flash.display.PixelSnapping;
enum flash.display.BlendMode;
@:require(flash10) flash.desktop.Clipboard
@:require(flash10) flash.desktop.ClipboardFormats
@:require(flash10) flash.desktop.ClipboardTransferMode
flash.display.Bitmap.pixelSnapping : PixelSnapping;
flash.display.Bitmap.$pixelSnapping : PixelSnapping;
flash.display.BitmapData.$blendMode : BlendMode;
flash.display.BitmapData.$redArray : Array;
flash.display.BitmapData.$greenArray : Array;
flash.display.BitmapData.$blueArray : Array;
flash.display.BitmapData.$alphaArray : Array;
flash.display.BitmapData.$offsets : Array;
@:require(flash10) flash.display.BitmapData.setVector
@:require(flash10) flash.display.BitmapData.getVector
@:require(flash10) flash.display.BitmapData.histogram
@:require(flash10_1) flash.display.Loader.uncaughtErrorEvents;
@:require(flash10_1) flash.display.LoaderInfo.isURLInaccessible;
@:require(flash10_1) flash.display.LoaderInfo.uncaughtErrorEvents;
@:require(flash10_1) flash.display.ColorCorrection
@:require(flash10_1) flash.display.ColorCorrectionSupport
@:require(flash10_1) flash.display.FocusDirection
@:require(flash10_1) flash.display.NativeMenu
@:require(flash10_1) flash.display.NativeMenuItem
@:require(flash10) flash.display.DisplayObject.blendShader
@:require(flash10) flash.display.DisplayObject.rotationX
@:require(flash10) flash.display.DisplayObject.rotationY
@:require(flash10) flash.display.DisplayObject.rotationZ
@:require(flash10) flash.display.DisplayObject.scaleZ
@:require(flash10) flash.display.DisplayObject.z
@:require(flash10) flash.display.DisplayObject.globalToLocal3D
@:require(flash10) flash.display.DisplayObject.local3DToGlobal
-flash.display.DisplayObject.new
flash.display.DisplayObject.blendMode : BlendMode;
flash.display.DisplayObject.opaqueBackground : Null;
flash.display.DisplayObjectContainer.getObjectsUnderPoint : Array;
@:require(flash10_1) flash.display.Sprite.startTouchDrag;
@:require(flash10_1) flash.display.Sprite.stopTouchDrag;
@:require(flash10_1) flash.display.Stage.wmodeGPU;
enum flash.display.GradientType;
enum flash.display.CapsStyle;
enum flash.display.JointStyle;
enum flash.display.GraphicsPathWinding;
enum flash.display.TriangleCulling;
enum flash.display.InterpolationMethod;
enum flash.display.LineScaleMode;
enum flash.display.ShaderParameterType;
enum flash.display.ShaderPrecision;
enum flash.display.SpreadMethod;
enum flash.display.StageAlign;
enum flash.display.StageDisplayState;
enum flash.display.StageQuality;
enum flash.display.StageScaleMode;
-flash.display.SWFVersion.new
flash.display.Graphics.$type : GradientType;
flash.display.Graphics.$colors : Array;
flash.display.Graphics.$spreadMethod : SpreadMethod;
flash.display.Graphics.$interpolationMethod : InterpolationMethod;
flash.display.Graphics.$scaleMode : LineScaleMode;
flash.display.Graphics.$caps : CapsStyle;
flash.display.Graphics.$joints : JointStyle;
flash.display.Graphics.$winding : GraphicsPathWinding;
flash.display.Graphics.$culling : TriangleCulling;
@:require(flash10) flash.display.Graphics.beginShaderFill
@:require(flash10) flash.display.Graphics.copyFrom
@:require(flash10) flash.display.Graphics.drawGraphicsData
@:require(flash10) flash.display.Graphics.drawPath
@:require(flash10) flash.display.Graphics.drawTriangles
@:require(flash10) flash.display.Graphics.lineBitmapStyle
@:require(flash10) flash.display.Graphics.lineShaderStyle
flash.display.GraphicsGradientFill.type : GradientType;
flash.display.GraphicsGradientFill.colors : Array;
flash.display.GraphicsGradientFill.spreadMethod : SpreadMethod;
flash.display.GraphicsGradientFill.interpolationMethod : InterpolationMethod;
flash.display.GraphicsGradientFill.alphas : Array;
flash.display.GraphicsGradientFill.ratios : Array;
flash.display.GraphicsGradientFill.$type : GradientType;
flash.display.GraphicsGradientFill.$colors : Array;
flash.display.GraphicsGradientFill.$spreadMethod : SpreadMethod;
flash.display.GraphicsGradientFill.$interpolationMethod : InterpolationMethod;
flash.display.GraphicsGradientFill.$alphas : Array;
flash.display.GraphicsGradientFill.$ratios : Array;
flash.display.GraphicsGradientFill.$matrix : flash.geom.Matrix;
flash.display.GraphicsPath.winding : GraphicsPathWinding;
flash.display.GraphicsPath.$winding : GraphicsPathWinding;
flash.display.GraphicsStroke.scaleMode : LineScaleMode;
flash.display.GraphicsStroke.caps : CapsStyle;
flash.display.GraphicsStroke.joints : JointStyle;
flash.display.GraphicsStroke.$scaleMode : LineScaleMode;
flash.display.GraphicsStroke.$caps : CapsStyle;
flash.display.GraphicsStroke.$joints : JointStyle;
flash.display.GraphicsTrianglePath.culling : TriangleCulling;
flash.display.GraphicsTrianglePath.$culling : TriangleCulling;
@:require(flash10) flash.display.Loader.unloadAndStop
enum flash.display.ActionScriptVersion;
enum flash.display.ColorCorrection;
enum flash.display.ColorCorrectionSupport;
-flash.display.LoaderInfo.new
flash.display.LoaderInfo.parameters : Dynamic;
flash.display.LoaderInfo.actionScriptVersion : ActionScriptVersion;
-flash.display.MorphShape.new
@:require(flash10) flash.display.MovieClip.currentFrameLabel
flash.display.MovieClip.currentLabels : Array;
flash.display.MovieClip.scenes : Array;
flash.display.Scene.labels : Array;
flash.display.Scene.$labels : Array;
@:require(flash10) flash.display.Shader;
flash.display.Shader.precisionHint : ShaderPrecision;
-flash.display.ShaderParameter.new
flash.display.ShaderParameter.type : ShaderParameterType;
-flash.display.Stage.new
flash.display.Stage.align : StageAlign;
flash.display.Stage.quality : StageQuality;
flash.display.Stage.scaleMode : StageScaleMode;
flash.display.Stage.colorCorrection : ColorCorrection;
flash.display.Stage.colorCorrectionSupport : ColorCorrectionSupport;
flash.display.Stage.displayState : StageDisplayState;
flash.display.Stage.displayState : StageDisplayState;
@:require(flash10) flash.display.Stage.colorCorrection
@:require(flash10) flash.display.Stage.colorCorrectionSupport
@:require(flash10_1) flash.errors.DRMManagerError
@:require(flash10_1) flash.events.AccelerometerEvent
@:require(flash10_1) flash.events.DRMAuthenticateEvent
@:require(flash10_1) flash.events.DRMAuthenticationCompleteEvent
@:require(flash10_1) flash.events.DRMAuthenticationErrorEvent
@:require(flash10_1) flash.events.DRMCustomProperties
@:require(flash10_1) flash.events.DRMErrorEvent
@:require(flash10_1) flash.events.DRMStatusEvent
@:require(flash10_1) flash.events.GeolocationEvent
@:require(flash10_1) flash.events.GestureEvent
@:require(flash10_1) flash.events.GesturePhase
@:require(flash10_1) flash.events.PressAndTapGestureEvent
@:require(flash10_1) flash.events.TouchEvent
@:require(flash10_1) flash.events.TransformGestureEvent
@:require(flash10_1) flash.events.UncaughtErrorEvent;
@:require(flash10_1) flash.events.UncaughtErrorEvents;
@:require(flash10) static flash.events.Event.CLEAR;
@:require(flash10) static flash.events.Event.COPY;
@:require(flash10) static flash.events.Event.CUT;
@:require(flash10) static flash.events.Event.EXIT_FRAME;
@:require(flash10) static flash.events.Event.FRAME_CONSTRUCTED;
@:require(flash10) static flash.events.Event.PASTE;
@:require(flash10) static flash.events.Event.SELECT_ALL;
@:require(flash10) flash.events.ContextMenuEvent.isMouseTargetInaccessible
@:require(flash10) flash.events.FocusEvent.isRelatedObjectInaccessible
@:require(flash10) flash.events.MouseEvent.isRelatedObjectInaccessible
flash.events.IEventDispatcher.$listener : Dynamic -> Void;
flash.events.EventDispatcher.$listener : Dynamic -> Void;
enum flash.events.EventPhase;
enum flash.events.GesturePhase;
flash.events.Event.eventPhase : EventPhase;
flash.events.KeyboardEvent.keyLocation : flash.ui.KeyLocation;
flash.events.KeyboardEvent.$keyLocationValue : flash.ui.KeyLocation;
flash.events.KeyboardEvent.$keyLocation : flash.ui.KeyLocation;
@:require(flash10_1) flash.events.ErrorEvent.errorID;
@:require(flash10_1) flash.events.HTTPStatusEvent.responseHeaders;
@:require(flash10_1) flash.events.HTTPStatusEvent.responseURL;
@:require(flash10_1) static flash.events.HTTPStatusEvent.HTTP_RESPONSE_STATUS;
@:require(flash10_1) flash.events.IMEEvent.imeClient;
@:require(flash10_1) static flash.events.IMEEvent.IME_START_COMPOSITION;
-flash.events.WeakFunctionClosure.new
-flash.external.ExternalInterface.new
enum flash.filters.BitmapFilterType;
enum flash.filters.DisplacementMapFilterMode;
flash.filters.BevelFilter.type : BitmapFilterType;
flash.filters.BevelFilter.$type : BitmapFilterType;
flash.filters.DisplacementMapFilter.mode : DisplacementMapFilterMode;
flash.filters.DisplacementMapFilter.$mode : DisplacementMapFilterMode;
flash.filters.GradientGlowFilter.type : BitmapFilterType;
flash.filters.GradientGlowFilter.$type : BitmapFilterType;
enum flash.geom.Orientation3D;
flash.geom.Matrix3D.$orientationStyle : Orientation3D;
@:require(flash10) flash.geom.Matrix3D;
@:require(flash10) flash.geom.Utils3D;
@:require(flash10) flash.geom.Vector3D;
@:require(flash10) flash.geom.PerspectiveProjection;
@:require(flash10) flash.geom.Transform.matrix3D;
@:require(flash10) flash.geom.Transform.perspectiveProjection;
@:require(flash10) flash.geom.Transform.getRelativeMatrix3D;
-flash.geom.Utils3D.new
@:require(flash10_1) static flash.media.Camera.isSupported;
@:require(flash10_1) static flash.media.Camera._scanHardware;
enum flash.media.SoundCodec;
flash.media.Microphone.codec : SoundCodec;
@:require(flash10) flash.media.Microphone.codec;
@:require(flash10) flash.media.Microphone.encodeQuality;
@:require(flash10) flash.media.Microphone.framesPerPacket;
@:require(flash10_1) flash.media.Microphone.enableVAD;
@:require(flash10_1) flash.media.Microphone.noiseSuppressionLevel;
@:require(flash10_1) static flash.media.Microphone.isSupported;
@:require(flash10) flash.media.Sound.extract;
@:require(flash10_1) flash.media.Sound.isURLInaccessible;
@:require(flash10) flash.net.FileReference.data;
@:require(flash10) flash.net.FileReference.load;
@:require(flash10) flash.net.FileReference.save;
-flash.media.SoundMixer.new
@:require(flash10_1) flash.net.LocalConnection.isPerUser;
@:require(flash10_1) static flash.net.LocalConnection.isSupported;
flash.net.FileReference.$typeFilter : Array;
flash.net.FileReferenceList.fileList : Array;
flash.net.FileReferenceList.$typeFilter : Array;
@:require(flash10_1) flash.net.GroupSpecifier;
@:require(flash10_1) flash.net.NetGroup;
@:require(flash10_1) flash.net.NetGroupInfo;
@:require(flash10_1) flash.net.NetStreamMulticastInfo;
@:require(flash10) flash.net.NetConnection.farID;
@:require(flash10) flash.net.NetConnection.farNonce;
@:require(flash10) flash.net.NetConnection.maxPeerConnections;
@:require(flash10) flash.net.NetConnection.nearID;
@:require(flash10) flash.net.NetConnection.nearNonce;
@:require(flash10) flash.net.NetConnection.protocol;
@:require(flash10) flash.net.NetConnection.unconnectedPeerStreams;
@:require(flash10) flash.net.NetStream.farID;
@:require(flash10) flash.net.NetStream.farNonce;
@:require(flash10) flash.net.NetStream.info;
@:require(flash10) flash.net.NetStream.maxPauseBufferTime;
@:require(flash10) flash.net.NetStream.nearNonce;
@:require(flash10) flash.net.NetStream.peerStreams;
@:require(flash10) flash.net.NetStream.onPeerConnect;
@:require(flash10) flash.net.NetStream.play2;
@:require(flash10) static flash.net.NetStream.CONNECT_TO_FMS;
@:require(flash10) static flash.net.NetStream.DIRECT_CONNECTIONS;
@:require(flash10_1) flash.net.NetStream.audioReliable;
@:require(flash10_1) flash.net.NetStream.audioSampleAccess;
@:require(flash10_1) flash.net.NetStream.backBufferLength;
@:require(flash10_1) flash.net.NetStream.backBufferTime;
@:require(flash10_1) flash.net.NetStream.bufferTimeMax;
@:require(flash10_1) flash.net.NetStream.dataReliable;
@:require(flash10_1) flash.net.NetStream.inBufferSeek;
@:require(flash10_1) flash.net.NetStream.multicastAvailabilitySendToAll;
@:require(flash10_1) flash.net.NetStream.multicastAvailabilityUpdatePeriod;
@:require(flash10_1) flash.net.NetStream.multicastFetchPeriod;
@:require(flash10_1) flash.net.NetStream.multicastInfo;
@:require(flash10_1) flash.net.NetStream.multicastPushNeighborLimit;
@:require(flash10_1) flash.net.NetStream.multicastRelayMarginDuration;
@:require(flash10_1) flash.net.NetStream.multicastWindowDuration;
@:require(flash10_1) flash.net.NetStream.videoReliable;
@:require(flash10_1) flash.net.NetStream.videoSampleAccess;
@:require(flash10_1) flash.net.NetStream.appendBytes;
@:require(flash10_1) flash.net.NetStream.appendBytesAction;
@:require(flash10_1) flash.net.NetStream.attach;
@:require(flash10_1) flash.net.NetStream.step;
@:require(flash10_1) flash.net.NetStreamInfo.videoLossRate;
@:require(flash10_1) flash.net.NetStreamPlayOptions.offset;
@:require(flash10_1) static flash.net.URLRequestMethod.DELETE;
@:require(flash10_1) static flash.net.URLRequestMethod.HEAD;
@:require(flash10_1) static flash.net.URLRequestMethod.OPTIONS;
@:require(flash10_1) static flash.net.URLRequestMethod.PUT;
@:require(flash10) flash.net.Socket.timeout;
@:require(flash10) flash.net.XMLSocket.timeout;
-flash.net.ObjectEncoding.new
-flash.net.URLRequestMethod.new
enum flash.net.URLLoaderDataFormat;
flash.net.Socket.endian : flash.utils.Endian;
flash.net.URLLoader.dataFormat : URLLoaderDataFormat;
flash.net.URLRequest.requestHeaders : Array;
flash.net.URLStream.endian : flash.utils.Endian;
enum flash.printing.PrintJobOrientation;
flash.printing.PrintJob.orientation : PrintJobOrientation;
@:require(flash10_1) static flash.printing.PrintJob.isSupported;
-flash.sampler.DeleteObjectSample.new
-flash.sampler.NewObjectSample.new
-flash.sampler.Sample.new
flash.sampler.Sample.stack : Array;
-flash.sampler.StackFrame.new
@:require(flash10_1) flash.sampler.NewObjectSample.size;
@:require(flash10_1) flash.sampler.StackFrame.scriptID;
-flash.system.Capabilities.new
-flash.system.IME.new
-flash.system.FSCommand.new
enum flash.system.IMEConversionMode;
static flash.system.IME.conversionMode : IMEConversionMode
@:require(flash10) flash.system.ApplicationDomain.domainMemory;
@:require(flash10) static flash.system.ApplicationDomain.MIN_DOMAIN_MEMORY_LENGTH;
@:require(flash10) static flash.system.Capabilities.isEmbeddedInAcrobat;
@:require(flash10) static flash.system.Capabilities.maxLevelIDC;
@:require(flash10_1) static flash.system.Capabilities.cpuArchitecture;
@:require(flash10_1) static flash.system.Capabilities.supports32BitProcesses;
@:require(flash10_1) static flash.system.Capabilities.supports64BitProcesses;
@:require(flash10_1) static flash.system.Capabilities.touchscreenType;
static flash.system.Capabilities.touchscreenType : TouchscreenType;
enum flash.system.TouchscreenType;
@:require(flash10_1) static flash.system.IME.isSupported;
@:require(flash10_1) static flash.system.IME.compositionAbandoned;
@:require(flash10_1) static flash.system.IME.compositionSelectionChanged;
@:require(flash10) flash.system.JPEGLoaderContext;
@:require(flash10_1) flash.system.LoaderContext.allowCodeImport;
@:require(flash10_1) flash.system.LoaderContext.allowLoadBytesCodeExecution;
@:require(flash10_1) static flash.system.Security.APPLICATION;
@:require(flash10_1) static flash.system.Security.duplicateSandboxBridgeInputArguments;
@:require(flash10_1) static flash.system.Security.duplicateSandboxBridgeOutputArgument;
@:require(flash10_1) static flash.system.System.currentTime;
@:require(flash10_1) static flash.system.System.freeMemory;
@:require(flash10_1) static flash.system.System.preciseStartupTime;
@:require(flash10_1) static flash.system.System.privateMemory;
@:require(flash10_1) static flash.system.System.totalMemoryNumber;
@:require(flash10_1) static flash.system.System.disposeXML;
@:require(flash10_1) static flash.system.System.nativeConstructionOnly;
enum flash.system.SecurityPanel;
-flash.system.Security.new
flash.system.Security.$panel : SecurityPanel
-flash.system.SecurityDomain.new
-flash.system.System.new
flash.system.SystemUpdater.$typer : SystemAdapterType;
enum flash.text.AntiAliasType;
enum flash.text.GridFitType;
enum flash.text.FontStyle;
enum flash.text.FontType;
enum flash.text.TextDisplayMode;
enum flash.text.TextFieldType;
enum flash.text.TextFieldAutoSize;
enum flash.text.TextFormatAlign;
enum flash.text.TextFormatDisplay;
enum flash.text.TextColorType;
flash.text.Font.fontStyle : FontStyle;
flash.text.Font.fontType : FontType;
static flash.text.Font.enumerateFonts : Array;
flash.text.TextField.autoSize : TextFieldAutoSize;
flash.text.TextField.antiAliasType : AntiAliasType;
flash.text.TextField.gridFitType : GridFitType;
flash.text.TextField.type : TextFieldType;
flash.text.TextFormat.align : TextFormatAlign;
flash.text.TextFormat.blockIndent : Null
flash.text.TextFormat.bold : Null;
flash.text.TextFormat.bullet : Null;
flash.text.TextFormat.color : Null;
flash.text.TextFormat.display : TextFormatDisplay;
flash.text.TextFormat.indent : Null;
flash.text.TextFormat.italic : Null;
flash.text.TextFormat.kerning : Null;
flash.text.TextFormat.leading : Null;
flash.text.TextFormat.leftMargin : Null;
flash.text.TextFormat.letterSpacing : Null;
flash.text.TextFormat.rightMargin : Null;
flash.text.TextFormat.size : Null;
flash.text.TextFormat.tabStops : Array;
flash.text.TextFormat.underline : Null;
flash.text.TextFormat.$size : Null;
flash.text.TextFormat.$color : Null;
flash.text.TextFormat.$bold : Null;
flash.text.TextFormat.$italic : Null;
flash.text.TextFormat.$underline : Null;
flash.text.TextFormat.$align : TextFormatAlign;
flash.text.TextFormat.$leftMargin : Null;
flash.text.TextFormat.$rightMargin : Null;
flash.text.TextFormat.$indent : Null;
flash.text.TextFormat.$leading : Null;
@:require(flash10) static flash.text.TextField.isFontCompatible;
-flash.text.TextRenderer.new
static flash.text.TextRenderer.antiAliasType : AntiAliasType;
static flash.text.TextRenderer.displayMode : TextDisplayMode;
flash.text.TextRenderer.$fontStyle : FontStyle;
flash.text.TextRenderer.$colorType : TextColorType;
@:require(flash10_1) static flash.text.engine.FontDescription.isDeviceFontCompatible;
@:require(flash10_1) flash.text.engine.SpaceJustifier.maximumSpacing;
@:require(flash10_1) flash.text.engine.SpaceJustifier.minimumSpacing;
@:require(flash10_1) flash.text.engine.SpaceJustifier.optimumSpacing;
@:require(flash10_1) flash.text.engine.TextBlock.recreateTextLine;
@:require(flash10_1) flash.text.engine.TextBlock.releaseLineCreationData;
@:require(flash10_1) flash.text.engine.TextLine.hasTabs;
flash.text.engine.ContentElement.textRotation : TextRotation;
flash.text.engine.ContentElement.$textRotation : TextRotation;
flash.text.engine.EastAsianJustifier.justificationStyle : JustificationStyle;
flash.text.engine.EastAsianJustifier.$justificationStyle : JustificationStyle;
flash.text.engine.EastAsianJustifier.$lineJustification : LineJustification;
enum flash.text.engine.BreakOpportunity;
enum flash.text.engine.CFFHinting;
enum flash.text.engine.DigitCase;
enum flash.text.engine.DigitWidth;
enum flash.text.engine.FontLookup;
enum flash.text.engine.FontPosture;
enum flash.text.engine.FontWeight;
enum flash.text.engine.JustificationStyle;
enum flash.text.engine.Kerning;
enum flash.text.engine.LigatureLevel;
enum flash.text.engine.LineJustification;
enum flash.text.engine.RenderingMode;
enum flash.text.engine.TabAlignment;
enum flash.text.engine.TextBaseline;
enum flash.text.engine.TextLineCreationResult;
enum flash.text.engine.TextLineValidity;
enum flash.text.engine.TextRotation;
enum flash.text.engine.TypographicCase;
flash.text.engine.ElementFormat.alignmentBaseline : TextBaseline;
flash.text.engine.ElementFormat.breakOpportunity : BreakOpportunity;
flash.text.engine.ElementFormat.digitCase : DigitCase;
flash.text.engine.ElementFormat.digitWidth : DigitWidth;
flash.text.engine.ElementFormat.dominantBaseline : TextBaseline;
flash.text.engine.ElementFormat.kerning : Kerning;
flash.text.engine.ElementFormat.ligatureLevel : LigatureLevel;
flash.text.engine.ElementFormat.textRotation : TextRotation;
flash.text.engine.ElementFormat.typographicCase : TypographicCase;
flash.text.engine.ElementFormat.$alignmentBaseline : TextBaseline;
flash.text.engine.ElementFormat.$breakOpportunity : BreakOpportunity;
flash.text.engine.ElementFormat.$digitCase : DigitCase;
flash.text.engine.ElementFormat.$digitWidth : DigitWidth;
flash.text.engine.ElementFormat.$dominantBaseline : TextBaseline;
flash.text.engine.ElementFormat.$kerning : Kerning;
flash.text.engine.ElementFormat.$ligatureLevel : LigatureLevel;
flash.text.engine.ElementFormat.$textRotation : TextRotation;
flash.text.engine.ElementFormat.$typographicCase : TypographicCase;
flash.text.engine.FontDescription.cffHinting : CFFHinting;
flash.text.engine.FontDescription.fontLookup : FontLookup;
flash.text.engine.FontDescription.fontPosture : FontPosture;
flash.text.engine.FontDescription.fontWeight : FontWeight;
flash.text.engine.FontDescription.renderingMode : RenderingMode;
flash.text.engine.FontDescription.$cffHinting : CFFHinting;
flash.text.engine.FontDescription.$fontLookup : FontLookup;
flash.text.engine.FontDescription.$fontPosture : FontPosture;
flash.text.engine.FontDescription.$fontWeight : FontWeight;
flash.text.engine.FontDescription.$renderingMode : RenderingMode;
flash.text.engine.GraphicElement.$textRotation : TextRotation;
flash.text.engine.GroupElement.$textRotation : TextRotation;
flash.text.engine.SpaceJustifier.$lineJustification : LineJustification;
flash.text.engine.TabStop.alignment : TabAlignment;
flash.text.engine.TabStop.$alignment : TabAlignment;
flash.text.engine.TextBlock.baselineZero : TextBaseline;
flash.text.engine.TextBlock.lineRotation : TextRotation;
flash.text.engine.TextBlock.textLineCreationResult : TextLineCreationResult;
flash.text.engine.TextBlock.$baselineZero : TextBaseline;
flash.text.engine.TextBlock.$lineRotation : TextRotation;
flash.text.engine.TextBlock.$textLineCreationResult : TextLineCreationResult;
flash.text.engine.TextElement.$textRotation : TextRotation;
flash.text.engine.TextJustifier.lineJustification : LineJustification;
flash.text.engine.TextJustifier.$lineJustification : LineJustification;
flash.text.engine.TextLine.baseline : TextBaseline;
-flash.trace.Trace.new
-static flash.xml.XMLList.length
-static flash.xml.XML.length
-flash.text.engine.TextElement.text
-flash.ui.Keyboard.new
-flash.ui.Mouse.new
enum flash.ui.MultitouchInputMode;
-flash.ui.Multitouch.new
flash.ui.Multitouch.inputMode : MultitouchInputMode;
@:require(flash10) flash.ui.ContextMenu.clipboardItems;
@:require(flash10) flash.ui.ContextMenu.clipboardMenu;
@:require(flash10) flash.ui.ContextMenu.link;
@:require(flash10_1) static flash.ui.ContextMenu.isSupported;
@:require(flash10) static flash.ui.Mouse.cursor;
static flash.ui.Mouse.cursor : Dynamic;
@:require(flash10_1) static flash.ui.Keyboard.A;
@:require(flash10_1) static flash.ui.Keyboard.B;
@:require(flash10_1) static flash.ui.Keyboard.C;
@:require(flash10_1) static flash.ui.Keyboard.D;
@:require(flash10_1) static flash.ui.Keyboard.E;
@:require(flash10_1) static flash.ui.Keyboard.F;
@:require(flash10_1) static flash.ui.Keyboard.G;
@:require(flash10_1) static flash.ui.Keyboard.H;
@:require(flash10_1) static flash.ui.Keyboard.I;
@:require(flash10_1) static flash.ui.Keyboard.J;
@:require(flash10_1) static flash.ui.Keyboard.K;
@:require(flash10_1) static flash.ui.Keyboard.L;
@:require(flash10_1) static flash.ui.Keyboard.M;
@:require(flash10_1) static flash.ui.Keyboard.N;
@:require(flash10_1) static flash.ui.Keyboard.O;
@:require(flash10_1) static flash.ui.Keyboard.P;
@:require(flash10_1) static flash.ui.Keyboard.Q;
@:require(flash10_1) static flash.ui.Keyboard.R;
@:require(flash10_1) static flash.ui.Keyboard.S;
@:require(flash10_1) static flash.ui.Keyboard.T;
@:require(flash10_1) static flash.ui.Keyboard.U;
@:require(flash10_1) static flash.ui.Keyboard.V;
@:require(flash10_1) static flash.ui.Keyboard.W;
@:require(flash10_1) static flash.ui.Keyboard.X;
@:require(flash10_1) static flash.ui.Keyboard.Y;
@:require(flash10_1) static flash.ui.Keyboard.Z;
@:require(flash10_1) static flash.ui.Keyboard.ALTERNATE;
@:require(flash10_1) static flash.ui.Keyboard.BACKQUOTE;
@:require(flash10_1) static flash.ui.Keyboard.BACKSLASH;
@:require(flash10_1) static flash.ui.Keyboard.COMMA;
@:require(flash10_1) static flash.ui.Keyboard.COMMAND;
@:require(flash10_1) static flash.ui.Keyboard.CharCodeStrings;
@:require(flash10_1) static flash.ui.Keyboard.EQUAL;
@:require(flash10_1) static flash.ui.Keyboard.LEFTBRACKET;
@:require(flash10_1) static flash.ui.Keyboard.MINUS;
@:require(flash10_1) static flash.ui.Keyboard.NUMBER_0;
@:require(flash10_1) static flash.ui.Keyboard.NUMBER_1;
@:require(flash10_1) static flash.ui.Keyboard.NUMBER_2;
@:require(flash10_1) static flash.ui.Keyboard.NUMBER_3;
@:require(flash10_1) static flash.ui.Keyboard.NUMBER_4;
@:require(flash10_1) static flash.ui.Keyboard.NUMBER_5;
@:require(flash10_1) static flash.ui.Keyboard.NUMBER_6;
@:require(flash10_1) static flash.ui.Keyboard.NUMBER_7;
@:require(flash10_1) static flash.ui.Keyboard.NUMBER_8;
@:require(flash10_1) static flash.ui.Keyboard.NUMBER_9;
@:require(flash10_1) static flash.ui.Keyboard.NUMPAD;
@:require(flash10_1) static flash.ui.Keyboard.PERIOD;
@:require(flash10_1) static flash.ui.Keyboard.QUOTE;
@:require(flash10_1) static flash.ui.Keyboard.RIGHTBRACKET;
@:require(flash10_1) static flash.ui.Keyboard.SEMICOLON;
@:require(flash10_1) static flash.ui.Keyboard.SLASH;
@:require(flash10_1) static flash.ui.Keyboard.hasVirtualKeyboard;
@:require(flash10_1) static flash.ui.Keyboard.physicalKeyboardType;
enum flash.ui.KeyboardType;
enum flash.ui.KeyLocation;
static flash.ui.Keyboard.physicalKeyboardType : KeyboardType;
@:require(flash10_1) flash.ui.Multitouch;
static flash.ui.Multitouch.inputMode : MultitouchInputMode;
@:require(flash10_1) flash.ui.MultitouchInputMode;
@:require(flash10_1) static flash.ui.Keyboard.STRING_BEGIN;
@:require(flash10_1) static flash.ui.Keyboard.STRING_BREAK;
@:require(flash10_1) static flash.ui.Keyboard.STRING_CLEARDISPLAY;
@:require(flash10_1) static flash.ui.Keyboard.STRING_CLEARLINE;
@:require(flash10_1) static flash.ui.Keyboard.STRING_DELETE;
@:require(flash10_1) static flash.ui.Keyboard.STRING_DELETECHAR;
@:require(flash10_1) static flash.ui.Keyboard.STRING_DELETELINE;
@:require(flash10_1) static flash.ui.Keyboard.STRING_DOWNARROW;
@:require(flash10_1) static flash.ui.Keyboard.STRING_END;
@:require(flash10_1) static flash.ui.Keyboard.STRING_EXECUTE;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F1;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F10;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F11;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F12;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F13;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F14;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F15;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F16;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F17;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F18;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F19;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F2;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F20;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F21;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F22;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F23;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F24;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F25;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F26;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F27;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F28;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F29;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F3;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F30;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F31;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F32;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F33;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F34;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F35;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F4;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F5;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F6;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F7;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F8;
@:require(flash10_1) static flash.ui.Keyboard.STRING_F9;
@:require(flash10_1) static flash.ui.Keyboard.STRING_FIND;
@:require(flash10_1) static flash.ui.Keyboard.STRING_HELP;
@:require(flash10_1) static flash.ui.Keyboard.STRING_HOME;
@:require(flash10_1) static flash.ui.Keyboard.STRING_INSERT;
@:require(flash10_1) static flash.ui.Keyboard.STRING_INSERTCHAR;
@:require(flash10_1) static flash.ui.Keyboard.STRING_INSERTLINE;
@:require(flash10_1) static flash.ui.Keyboard.STRING_LEFTARROW;
@:require(flash10_1) static flash.ui.Keyboard.STRING_MENU;
@:require(flash10_1) static flash.ui.Keyboard.STRING_MODESWITCH;
@:require(flash10_1) static flash.ui.Keyboard.STRING_NEXT;
@:require(flash10_1) static flash.ui.Keyboard.STRING_PAGEDOWN;
@:require(flash10_1) static flash.ui.Keyboard.STRING_PAGEUP;
@:require(flash10_1) static flash.ui.Keyboard.STRING_PAUSE;
@:require(flash10_1) static flash.ui.Keyboard.STRING_PREV;
@:require(flash10_1) static flash.ui.Keyboard.STRING_PRINT;
@:require(flash10_1) static flash.ui.Keyboard.STRING_PRINTSCREEN;
@:require(flash10_1) static flash.ui.Keyboard.STRING_REDO;
@:require(flash10_1) static flash.ui.Keyboard.STRING_RESET;
@:require(flash10_1) static flash.ui.Keyboard.STRING_RIGHTARROW;
@:require(flash10_1) static flash.ui.Keyboard.STRING_SCROLLLOCK;
@:require(flash10_1) static flash.ui.Keyboard.STRING_SELECT;
@:require(flash10_1) static flash.ui.Keyboard.STRING_STOP;
@:require(flash10_1) static flash.ui.Keyboard.STRING_SYSREQ;
@:require(flash10_1) static flash.ui.Keyboard.STRING_SYSTEM;
@:require(flash10_1) static flash.ui.Keyboard.STRING_UNDO;
@:require(flash10_1) static flash.ui.Keyboard.STRING_UPARROW;
@:require(flash10_1) static flash.ui.Keyboard.STRING_USER;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_BEGIN;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_BREAK;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_CLEARDISPLAY;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_CLEARLINE;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_DELETE;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_DELETECHAR;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_DELETELINE;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_DOWNARROW;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_END;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_EXECUTE;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F1;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F10;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F11;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F12;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F13;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F14;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F15;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F16;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F17;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F18;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F19;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F2;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F20;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F21;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F22;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F23;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F24;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F25;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F26;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F27;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F28;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F29;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F3;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F30;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F31;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F32;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F33;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F34;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F35;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F4;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F5;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F6;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F7;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F8;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_F9;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_FIND;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_HELP;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_HOME;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_INSERT;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_INSERTCHAR;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_INSERTLINE;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_LEFTARROW;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_MENU;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_MODESWITCH;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_NEXT;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_PAGEDOWN;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_PAGEUP;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_PAUSE;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_PREV;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_PRINT;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_PRINTSCREEN;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_REDO;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_RESET;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_RIGHTARROW;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_SCROLLLOCK;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_SELECT;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_STOP;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_SYSREQ;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_SYSTEM;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_UNDO;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_UPARROW;
@:require(flash10_1) static flash.ui.Keyboard.KEYNAME_USER;
@:require(flash10_1) static flash.ui.Mouse.supportsCursor;
enum flash.utils.Endian;
@:native("RegExp") flash.utils.RegExp;
-static flash.utils.RegExp.length;
flash.utils.ObjectInput.endian : Endian;
flash.utils.ObjectOutput.endian : Endian;
flash.utils.ByteArray.endian : Endian;
flash.utils.IDataInput.endian : Endian;
flash.utils.IDataOutput.endian : Endian;
@:require(flash10) flash.utils.ByteArray.clear;
@:require(flash10) flash.utils.ByteArray.deflate;
@:require(flash10) flash.utils.ByteArray.inflate;
@:require(flash10) flash.utils.SetIntervalTimer.clearArrayEntry;
-flash.utils.Namespace.toString
-flash.utils.Namespace.valueOf
-static flash.utils.Namespace.length
-flash.utils.QName.toString
-flash.utils.QName.valueOf
-static flash.utils.QName.length
enum flash.xml.XMLNodeType;
flash.xml.XMLNode.nodeType : XMLNodeType;
flash.xml.XMLNode.$type : XMLNodeType;
flash.xml.XML.namespace : flash.utils.Namespace;
flash.xml.XML.parent : XML;
flash.xml.XMLList.namespace : flash.utils.Namespace;
flash.xml.XMLList.parent : XML;
flash.xml.XMLTag.type : XMLNodeType;
enum flash.system.SystemUpdaterType;
@:require(flash10_1) flash.system.SystemUpdater;
flash.system.SystemUpdater.$type : SystemUpdaterType;
@:require(flash10_1) flash.sensors.Accelerometer;
@:require(flash10_1) flash.sensors.Geolocation;
@:require(flash10_1) flash.globalization.Collator;
@:require(flash10_1) flash.globalization.CurrencyFormatter;
@:require(flash10_1) flash.globalization.DateTimeFormatter;
@:require(flash10_1) flash.globalization.LocaleID;
@:require(flash10_1) flash.globalization.StringTools;
@:require(flash10_1) flash.globalization.NumberFormatter;
@:require(flash10_1) flash.globalization.NumberParseResult;
enum flash.globalization.CollatorMode;
enum flash.globalization.DateTimeNameContext;
enum flash.globalization.DateTimeNameStyle;
enum flash.globalization.DateTimeStyle;
enum flash.globalization.LastOperationStatus;
enum flash.globalization.NationalDigitsType;
flash.globalization.Collator.lastOperationStatus : LastOperationStatus;
flash.globalization.Collator.$initialMode : CollatorMode;
flash.globalization.CurrencyFormatter.lastOperationStatus : LastOperationStatus;
flash.globalization.DateTimeFormatter.lastOperationStatus : LastOperationStatus;
flash.globalization.DateTimeFormatter.$dateStyle : DateTimeStyle;
flash.globalization.DateTimeFormatter.$nameStyle : DateTimeNameStyle;
flash.globalization.DateTimeFormatter.$timeStyle : DateTimeStyle;
flash.globalization.DateTimeFormatter.$context : DateTimeNameContext;
flash.globalization.DateTimeFormatter.getDateStyle : DateTimeStyle;
flash.globalization.DateTimeFormatter.getTimeStyle : DateTimeStyle;
flash.globalization.DateTimeFormatter.getDateTimePattern : DateTimeStyle;
flash.globalization.LocaleID.lastOperationStatus : LastOperationStatus;
flash.globalization.NumberFormatter.lastOperationStatus : LastOperationStatus;
flash.globalization.NumberFormatter.digitsType : NationalDigitsType;
flash.globalization.StringTools.lastOperationStatus : LastOperationStatus;
// FP 10.2
@:require(flash10_2) flash.ui.MouseCursorData;
@:require(flash10_2) flash.events.StageVideoEvent;
@:require(flash10_2) flash.events.VideoEvent;
@:require(flash10_2) flash.media.MicrophoneEnhancedMode;
@:require(flash10_2) flash.media.MicrophoneEnhancedOptions;
@:require(flash10_2) flash.media.StageVideo;
@:require(flash10_2) flash.display.Stage.color;
@:require(flash10_2) flash.display.Stage.stageVideos;
@:require(flash10_2) flash.media.Microphone.enhancedOptions;
@:require(flash10_2) static flash.media.Microphone.getEnhancedMicrophone;
@:require(flash10_2) flash.system.Capabilities.allowsFullScreen;
@:require(flash10_2) static flash.ui.Keyboard.AUDIO;
@:require(flash10_2) static flash.ui.Keyboard.BACK;
@:require(flash10_2) static flash.ui.Keyboard.BLUE;
@:require(flash10_2) static flash.ui.Keyboard.CHANNEL_DOWN;
@:require(flash10_2) static flash.ui.Keyboard.CHANNEL_UP;
@:require(flash10_2) static flash.ui.Keyboard.DVR;
@:require(flash10_2) static flash.ui.Keyboard.EXIT;
@:require(flash10_2) static flash.ui.Keyboard.FAST_FORWARD;
@:require(flash10_2) static flash.ui.Keyboard.GREEN;
@:require(flash10_2) static flash.ui.Keyboard.GUIDE;
@:require(flash10_2) static flash.ui.Keyboard.HELP;
@:require(flash10_2) static flash.ui.Keyboard.INFO;
@:require(flash10_2) static flash.ui.Keyboard.INPUT;
@:require(flash10_2) static flash.ui.Keyboard.LAST;
@:require(flash10_2) static flash.ui.Keyboard.LIVE;
@:require(flash10_2) static flash.ui.Keyboard.MASTER_SHELL;
@:require(flash10_2) static flash.ui.Keyboard.MENU;
@:require(flash10_2) static flash.ui.Keyboard.NEXT;
@:require(flash10_2) static flash.ui.Keyboard.PAUSE;
@:require(flash10_2) static flash.ui.Keyboard.PLAY;
@:require(flash10_2) static flash.ui.Keyboard.PREVIOUS;
@:require(flash10_2) static flash.ui.Keyboard.RECORD;
@:require(flash10_2) static flash.ui.Keyboard.RED;
@:require(flash10_2) static flash.ui.Keyboard.REWIND;
@:require(flash10_2) static flash.ui.Keyboard.SEARCH;
@:require(flash10_2) static flash.ui.Keyboard.SETUP;
@:require(flash10_2) static flash.ui.Keyboard.SKIP_BACKWARD;
@:require(flash10_2) static flash.ui.Keyboard.SKIP_FORWARD;
@:require(flash10_2) static flash.ui.Keyboard.STOP;
@:require(flash10_2) static flash.ui.Keyboard.SUBTITLE;
@:require(flash10_2) static flash.ui.Keyboard.VOD;
@:require(flash10_2) static flash.ui.Keyboard.YELLOW;
@:require(flash10_2) static flash.ui.Mouse.registerCursor;
enum flash.media.MicrophoneEnhancedMode;
flash.media.MicrophoneEnhancedOptions.mode : MicrophoneEnhancedMode;
enum flash.display.FocusDirection;
// FLASH 11 FEATURES
-flash.automation.Configuration.new
@:require(flash11) flash.display.DisplayObjectContainer.removeChildren;
@:require(flash11) flash.display.Graphics.cubicCurveTo;
@:require(flash11) flash.display.GraphicsPath.cubicCurveTo;
@:require(flash11) flash.display.InteractiveObject.needsSoftKeyboard;
@:require(flash11) flash.display.InteractiveObject.softKeyboardInputAreaOfInterest;
@:require(flash11) flash.display.InteractiveObject.requestSoftKeyboard;
@:require(flash11) flash.display.MovieClip.isPlaying;
@:require(flash11) flash.display.Stage.displayContextInfo;
@:require(flash11) flash.display.Stage.softKeyboardRect;
@:require(flash11) flash.display.Stage.stage3Ds;
@:require(flash11) flash.display.Stage3D;
-flash.display.Stage.constructor;
-flash.display.Stage.hasOwnProperty;
-flash.display.Stage.isPrototypeOf;
-flash.display.Stage.propertyIsEnumerable;
-flash.display.Stage.setPropertyIsEnumerable;
-flash.display.Stage.toLocaleString;
-flash.display.Stage.valueOf;
enum flash.display3D.Context3DBlendFactor;
enum flash.display3D.;
@:require(flash11) static flash.events.Event.CONTEXT3D_CREATE;
@:require(flash11) static flash.events.Event.TEXT_INTERACTION_MODE_CHANGE;
@:require(flash11) static flash.events.StageVideoEvent.RENDER_STATUS_AVAILABLE;
@:require(flash11) static flash.events.StageVideoEvent.STAGE_VIDEO_STATE;
@:require(flash11) flash.geom.Matrix3D.copyColumnFrom;
@:require(flash11) flash.geom.Matrix3D.copyColumnTo;
@:require(flash11) flash.geom.Matrix3D.copyFrom;
@:require(flash11) flash.geom.Matrix3D.copyRawDataFrom;
@:require(flash11) flash.geom.Matrix3D.copyRawDataTo;
@:require(flash11) flash.geom.Matrix3D.copyRowFrom;
@:require(flash11) flash.geom.Matrix3D.copyRowTo;
@:require(flash11) flash.geom.Matrix3D.copyToMatrix3D;
@:require(flash11) flash.geom.Matrix.copyColumnFrom;
@:require(flash11) flash.geom.Matrix.copyColumnTo;
@:require(flash11) flash.geom.Matrix.copyFrom;
@:require(flash11) flash.geom.Matrix.copyRowFrom;
@:require(flash11) flash.geom.Matrix.copyRowTo;
@:require(flash11) flash.geom.Matrix.setTo;
@:require(flash11) flash.geom.Point.copyFrom;
@:require(flash11) flash.geom.Point.setTo;
@:require(flash11) flash.geom.Rectangle.copyFrom;
@:require(flash11) flash.geom.Rectangle.setTo;
@:require(flash11) flash.geom.Vector3D.copyFrom;
@:require(flash11) flash.geom.Vector3D.setTo;
@:require(flash11) flash.media.Sound.loadCompressedDataFromByteArray;
@:require(flash11) flash.media.Sound.loadPCMFromByteArray;
@:require(flash11) flash.net.Socket.bytesPending;
-flash.display3D.Context3DClearMask.new;
enum flash.display3D.Context3DCompareMode;
enum flash.display3D.Context3DProgramType;
enum flash.display3D.Context3DRenderMode;
enum flash.display3D.Context3DStencilAction;
enum flash.display3D.Context3DTextureFormat;
enum flash.display3D.Context3DTriangleFace;
enum flash.display3D.Context3DVertexBufferFormat;
-flash.display.Stage3D.new;
-flash.display3D.Context3D.new;
-flash.display3D.IndexBuffer3D.new;
-flash.display3D.Program3D.new;
-flash.display3D.VertexBuffer3D.new;
-flash.display3D.textures.CubeTexture.new;
-flash.display3D.textures.TextureBase.new;
-flash.display3D.textures.Texture.new;
flash.display3D.Context3D.$sourceFactor : Context3DBlendFactor;
flash.display3D.Context3D.$destinationFactor : Context3DBlendFactor;
flash.display3D.Context3D.$format : Context3DTextureFormat;
flash.display3D.Context3D.$triangleFaceToCull : Context3DTriangleFace;
flash.display3D.Context3D.$triangleFace : Context3DTriangleFace;
flash.display3D.Context3D.$passCompareMode : Context3DCompareMode;
flash.display3D.Context3D.$compareMode : Context3DCompareMode;
flash.display3D.Context3D.$programType : Context3DProgramType;
flash.display3D.Context3D.$actionOnBothPass : Context3DStencilAction;
flash.display3D.Context3D.$actionOnDepthFail : Context3DStencilAction;
flash.display3D.Context3D.$actionOnDepthPassStencilFail : Context3DStencilAction;
flash.display3D.Context3D.$setVertexBufferAt__format : Context3DVertexBufferFormat;
@:require(flash11) flash.net.NetStream.useHardwareDecoder;
@:require(flash11) flash.net.NetStream.videoStreamSettings;
@:require(flash11) flash.net.SecureSocket;
@:require(flash11) flash.net.NetMonitor;
@:require(flash11) static flash.system.Capabilities.hasMultiChannelAudio;
@:require(flash11) flash.system.LoaderContext.imageDecodingPolicy;
@:require(flash11) flash.system.LoaderContext.parameters;
@:require(flash11) flash.system.LoaderContext.requestedContentParent;
enum flash.system.ImageDecodingPolicy;
flash.system.LoaderContext.imageDecodingPolicy : ImageDecodingPolicy;
@:require(flash11) static flash.system.Security.pageDomain;
@:require(flash11) static flash.system.System.processCPUUsage;
@:require(flash11) static flash.system.System.pauseForGCIfCollectionImminent;
@:require(flash11) static flash.ui.Mouse.supportsNativeCursor;
@:require(flash11) static flash.ui.Mouse.unregisterCursor;
-flash.ui.MouseCursor.new;
@:require(flash11) flash.utils.CompressionAlgorithm;
enum flash.utils.CompressionAlgorithm;
@:require(flash11) flash.xml.XML.toJSON;
@:require(flash11) flash.xml.XMLList.toJSON;
flash.utils.ByteArray.$algorithm : CompressionAlgorithm;
@:require(flash11) flash.text.TextField.textInteractionMode;
enum flash.text.TextInteractionMode;
flash.text.TextField.textInteractionMode : TextInteractionMode;
// 11.2
enum flash.display.BitmapCompressColorSpace;
@:require(flash11_2) flash.display.BitmapData.compress;
@:require(flash11_2) flash.media.Camera.position;
@:require(flash11_2) flash.net.NetStream.dispose;
@:require(flash11_2) flash.display.StageWorker;
@:require(flash11_2) flash.display.Worker;
@:require(flash11_8) flash.events.GameInputEvent;
@:require(flash11_2) flash.events.ThrottleEvent;
flash.events.ThrottleEvent.$type : ThrottleType;
enum flash.events.ThrottleType;
@:require(flash11_8) flash.ui.GameInput;
@:require(flash11_8) flash.ui.GameInputDevice;
-flash.ui.GameInput.new;
@:require(flash11_2) flash.utils.Telemetry;
enum flash.ui.GameInputFinger;
enum flash.ui.GameInputHand;
enum flash.ui.GameInputControlType;
flash.ui.GameInputControl.finger : flash.ui.GameInputFinger;
flash.ui.GameInputControl.hand : flash.ui.GameInputHand;
flash.ui.GameInputControl.type : flash.ui.GameInputControlType;
// 11.2
@:require(flash11_2) flash.display3D.Context3D.setProgramConstantsFromByteArray
@:require(flash11_2) flash.display.Stage.mouseLock;
@:require(flash11_2) flash.events.MouseEvent.movementX;
@:require(flash11_2) flash.events.MouseEvent.movementY;
@:require(flash11_2) static flash.events.MouseEvent.CONTEXT_MENU;
@:require(flash11_2) static flash.events.MouseEvent.MIDDLE_CLICK;
@:require(flash11_2) static flash.events.MouseEvent.MIDDLE_MOUSE_DOWN;
@:require(flash11_2) static flash.events.MouseEvent.MIDDLE_MOUSE_UP;
@:require(flash11_2) static flash.events.MouseEvent.RIGHT_CLICK;
@:require(flash11_2) static flash.events.MouseEvent.RIGHT_MOUSE_DOWN;
@:require(flash11_2) static flash.events.MouseEvent.RIGHT_MOUSE_UP;
// 11.3
@:require(flash11_3) flash.display.BitmapData.drawWithQuality
flash.display.BitmapData.$quality : StageQuality;
enum flash.display.BitmapEncodingColorSpace;
flash.display.JPEGXREncoderOptions.$colorSpace : BitmapEncodingColorSpace;
flash.display.JPEGXREncoderOptions.colorSpace : BitmapEncodingColorSpace;
@:require(flash11_3) flash.display.BitmapData.encode
@:require(flash11_3) flash.display.Stage.allowsFullScreenInteractive
@:require(flash11_3) static flash.events.Event.FRAME_LABEL;
@:require(flash11_3) static flash.events.Event.SUSPEND;
@:require(flash11_3) static flash.events.FullScreenEvent.FULL_SCREEN_INTERACTIVE_ACCEPTED;
@:require(flash11_3) flash.events.FullScreenEvent.interactive;
@:require(flash11_3) static flash.events.MouseEvent.RELEASE_OUTSIDE;
@:require(flash11_3) flash.net.NetStream.useJitterBuffer;
@:require(flash11_3) flash.system.ApplicationDomain.getQualifiedDefinitionNames;
@:require(flash11_3) flash.system.SecurityDomain.domainID;
@:require(flash11_3) flash.system.ApplicationInstaller;
@:require(flash11_3) flash.system.AuthorizedFeatures;
@:require(flash11_3) flash.system.AuthorizedFeaturesLoader;
@:require(flash11_3) static flash.events.Event.TEXTURE_READY;
// 11.4
@:require(flash11_4) flash.display.BitmapData.copyPixelsToByteArray;
@:require(flash11_4) flash.concurrent.Mutex;
@:require(flash11_4) flash.concurrent.Condition;
enum flash.display3D.Context3DProfile;
flash.display.Stage3D.$profile : flash.display3D.Context3DProfile;
@:require(flash11_4) flash.display.LoaderInfo.childSandboxBridge;
@:require(flash11_4) flash.display.LoaderInfo.parentSandboxBridge;
@:require(flash11_4) flash.display.Stage.contentsScaleFactor;
@:require(flash11_4) flash.media.Camera.copyToByteArray;
@:require(flash11_4) flash.media.Camera.copyToVector;
@:require(flash11_4) flash.media.Camera.drawToBitmapData;
@:require(flash11_4) flash.media.StageVideo.attachCamera;
@:require(flash11_4) flash.net.URLStream.diskCacheEnabled;
@:require(flash11_4) flash.net.URLStream.length;
@:require(flash11_4) flash.net.URLStream.position;
@:require(flash11_4) flash.net.URLStream.stop;
@:require(flash11_4) flash.system.AuthorizedFeatures.enableDiskCache;
@:require(flash11_4) flash.system.AuthorizedFeatures.isFeatureEnabled;
@:require(flash11_4) flash.system.AuthorizedFeatures.isNegativeToken;
@:require(flash11_4) flash.system.AuthorizedFeaturesLoader.makeGlobal;
@:require(flash11_4) flash.utils.ByteArray.shareable;
@:require(flash11_4) flash.utils.ByteArray.atomicCompareAndSwapIntAt;
@:require(flash11_4) flash.utils.ByteArray.atomicCompareAndSwapLength;
//not supported @:require(flash11_4) flash.utils.CompressionAlgorithm.LZMA;
@:require(flash11_4) flash.system.Worker;
@:require(flash11_4) flash.system.WorkerDomain;
@:require(flash11_4) flash.system.MessageChannel;
-flash.system.Worker.new;
-flash.system.MessageChannel.new;
flash.system.Worker.state : WorkerState;
flash.system.MessageChannel.state : MessageChannelState;
enum flash.system.WorkerState;
// --- 11.6 API
enum flash.display3D.Context3DMipFilter
enum flash.display3D.Context3DTextureFilter
enum flash.display3D.Context3DWrapMode
enum flash.system.ApplicationInstallerMode
@:require(flash11_6) flash.display3D.Context3D.setSamplerStateAt
flash.display3D.Context3D.$wrap : Context3DWrapMode;
flash.display3D.Context3D.$filter : Context3DTextureFilter;
flash.display3D.Context3D.$mipfilter : Context3DMipFilter;
-flash.display.DisplayObject.metaData
@:require(flash11_6) flash.display.Graphics.readGraphicsData
@:require(flash11_7) flash.media.StageVideo.attachAVStream;
@:require(flash11_7) static flash.net.SharedObject.preventBackup;
@:require(flash11_7) flash.system.AuthorizedFeatures.enableHLSPlayback;
@:require(flash11_7) flash.system.AuthorizedFeaturesLoader.loadAuthorizedFeaturesFromData;
@:require(flash11_8) flash.display.DisplayObjectContainer.stopAllMovieClips
@:require(flash11_8) flash.display3D.Context3D.createRectangleTexture
@:require(flash12) flash.display.Stage3D.requestContext3DMatchingProfiles
@:require(flash12) flash.display3D.Context3D.profile
flash.display3D.Context3D.$bufferUsage : Context3DBufferUsage
enum flash.display3D.Context3DBufferUsage
@:native("flash.profiler.Telemetry") flash.utils.Telemetry
@:require(flash12) flash.display3D.Context3DBufferUsage
haxe_3.2.1+dfsg.orig/extra/haxeserver.bat 0000664 0001750 0001750 00000000073 12607337712 020313 0 ustar andy andy 0000000 0000000 @echo off
nekotools server -p 2000 -h localhost -d .\
pause haxe_3.2.1+dfsg.orig/extra/images/Banner.bmp 0000664 0001750 0001750 00000064072 12607337712 020632 0 ustar andy andy 0000000 0000000 BM:h – ( – 9 ¤d Ø Ø 3 f ™ Ì ÿ 3 33 3f 3™ 3Ì 3ÿ f f3 ff f™ fÌ fÿ ™ ™3 ™f ™™ ™Ì ™ÿ Ì Ì3 Ìf Ì™ ÌÌ Ìÿ ÿ ÿ3 ÿf ÿ™ ÿÌ ÿÿ 3 3 3 3 f 3 ™ 3 Ì 3 ÿ 33 333 33f 33™ 33Ì 33ÿ 3f 3f3 3ff 3f™ 3fÌ 3fÿ 3™ 3™3 3™f 3™™ 3™Ì 3™ÿ 3Ì 3Ì3 3Ìf 3Ì™ 3ÌÌ 3Ìÿ 3ÿ 3ÿ3 3ÿf 3ÿ™ 3ÿÌ 3ÿÿ f f 3 f f f ™ f Ì f ÿ f3 f33 f3f f3™ f3Ì f3ÿ ff ff3 fff ff™ ffÌ ffÿ f™ f™3 f™f f™™ f™Ì f™ÿ fÌ fÌ3 fÌf fÌ™ fÌÌ fÌÿ fÿ fÿ3 fÿf fÿ™ fÿÌ fÿÿ ™ ™ 3 ™ f ™ ™ ™ Ì ™ ÿ ™3 ™33 ™3f ™3™ ™3Ì ™3ÿ ™f ™f3 ™ff ™f™ ™fÌ ™fÿ ™™ ™™3 ™™f ™™™ ™™Ì ™™ÿ ™Ì ™Ì3 ™Ìf ™Ì™ ™ÌÌ ™Ìÿ ™ÿ ™ÿ3 ™ÿf ™ÿ™ ™ÿÌ ™ÿÿ Ì Ì 3 Ì f Ì ™ Ì Ì Ì ÿ Ì3 Ì33 Ì3f Ì3™ Ì3Ì Ì3ÿ Ìf Ìf3 Ìff Ìf™ ÌfÌ Ìfÿ Ì™ Ì™3 Ì™f Ì™™ Ì™Ì Ì™ÿ ÌÌ ÌÌ3 ÌÌf ÌÌ™ ÌÌÌ ÌÌÿ Ìÿ Ìÿ3 Ìÿf Ìÿ™ ÌÿÌ Ìÿÿ ÿ ÿ 3 ÿ f ÿ ™ ÿ Ì ÿ ÿ ÿ3 ÿ33 ÿ3f ÿ3™ ÿ3Ì ÿ3ÿ ÿf ÿf3 ÿff ÿf™ ÿfÌ ÿfÿ ÿ™ ÿ™3 ÿ™f ÿ™™ ÿ™Ì ÿ™ÿ ÿÌ ÿÌ3 ÿÌf ÿÌ™ ÿÌÌ ÿÌÿ ÿÿ ÿÿ3 ÿÿf ÿÿ™ ÿÿÌ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÓÓÓ§§§®®®ßßßþþþÄÄÄ™™™µµµÏÏÏ™™™ªªªüüüåååþþþ³³³™™™¨¨¨§§§™™™ÌÌÌÿÿÿãããµµµ§§§™™™ÝÝݧ§§™™™§§§§§§™™™§§§ÁÁÁåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÓÓÓCCCCCCÝÝÝÿÿÿÀÀÀCCCCCCöööEEECCC§§§ååååååVVVCCCfff………CCCCCCØØØÿÿÿCCCCCCHHHúúúCCCCCCCCCCCCCCCCCC|||ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÒÒÒCCCRRRñññþþþCCCaaaåååTTTCCCXXX___\\\DDDHHHÊÊʳ³³CCCEEE¶¶¶‡‡‡CCCJJJÉÉÉÑÑÑCCCCCCJJJMMMMMMMMM€€€ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿ¾¾¾CCCCCCÂÂÂöööÂÂÂCCCCCCÿÿÿ¼¼¼CCCCCCqqqcccCCCEEEøøøÿÿÿÔÔÔCCCCCCCCCCCCwwwåååÿÿÿCCCCCC‹‹‹îîîÖÖÖîîîóóóåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÒÒÒBBBBBBBBBBBBBBBBBBBBBþþþüüüNNNCCC¯¯¯~~~CCCdddÿÿÿÿÿÿÿÿÿ•••CCCCCCIIIùùùþþþþþþBBBBBBBBBBBBBBBBBBÛÛÛÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþÑÑÑBBBBBBBBBBBBBBBBBBBBBýýýýýýˆˆˆBBBbbbOOOBBBÐÐÐþþþþþþþþþŠŠŠBBBBBBFFFóóóýýýýýýBBBBBBXXXwwwwwwwwwÛÛÛþþþþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿþþþäääþþþýýý½½½BBBBBBÃÃÃùùùÁÁÁBBBBBBüüüâââïïïBBBBBBBBBBBBãããþþþþþþÇÇÇBBBBBBDDDBBBkkkâââüüüBBBBBB‚‚‚ÙÙÙÃÃÃÚÚÚïïïãããþþþþþþäääÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþýýýýýýÐÐÐBBBAAAÚÚÚûûû½½½AAAAAAúúúûûûûûûFFFBBBBBB~~~üüüýýýöööDDDBBBcccâââAAAAAA¸¸¸úúúAAAAAAAAAAAAAAABBB{{{üüüýýýþþþþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþýýýüüüüüüää䤤¤òòò÷÷÷¹¹¹œœœªªªøøøøøøøøø¨¨¨ŸŸŸîîîúúúùùù¸¸¸¡¡¡åååæææÆÆÆàààœœœœœœœœœœœœ¶¶¶ûûûüüüýýýýýýþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞþþþýýýâââüüüûûûàààùùùøøøÝÝÝööööööÜÜÜööööööÜÜÜ÷÷÷÷÷÷ÞÞÞøøøùùùßßßùùùùùùßßßøøøøøøÞÞÞ÷÷÷÷÷÷ÜÜÜööööööÜÜÜööö÷÷÷ÝÝÝøøøùùùàààûûûüüüãããýýýþþþåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþýýýüüüûûûúúúøøø÷÷÷öööõõõõõõôôôôôôóóóôôôôôôôôôõõõõõõööö÷÷÷÷÷÷÷÷÷÷÷÷÷÷÷ööööööõõõõõõôôôôôôôôôôôôôôôôôôõõõõõõ÷÷÷øøøùùùúúúûûûüüüýýýþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþýýýüüüûûûúúúøøøíñöÏÝôÏÜóÍÛòÌÚñÌÚñÌÙðËÙðÖàðñññòòòóóóóóóôôôôôôõõõõõõõõõõõõôôôôôôóóóòòòòòòÛçðËàñËàñËàñÌàñÍáòÎãóÎãôÛèõøøøùùùûûûüüüýýýþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿþþþÞÞÞýýýûûûàààùùù÷÷÷´Ôá ú™ù ˆ÷ tô!mó!nó!oó!oóA‚ð¸ÍñîîîÖÖÖððððððØØØññññññØØØððððððÖÖÖíîîÇö+™õ ”÷ ”÷ •÷ ”÷ ÷ €õ uô{«öÜÜÜ÷÷÷úúúáááüüüýýýäääÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýýýýûûûúúúøøøööö¼íöû¦ú¦ú¦ú§úŸù …ö!qó!mó!oó-vóÈØñíííîîîîîîîîîîîîîîîîîîííí”Éö%—÷ ”÷ –÷ ÷ õ qô!oô!oó!oó!oóc’ôõõõöööùùùúúúüüüýýýþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýüüüûûûùùùøøøõõõºñõÊý¦ú¦ú¦ú¦ú¦ú¦ú§ú¨ú šù …ö tô;€óÂÑììììììììììçêìšÉð$–ö ÷ õ tô!mó!oó!oó!oó!oó!oó!oó!póc‹óôôôöööøøøúúúûûûýýýþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿþþþÝÝÝüüüúúúßßß÷÷÷ôôô¥Ýáæÿ¥ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¨ú¥úšù;—ó¼ØøšÇù&„ó tô!oó!nó!oó!oó!oó!oó!oó!oó!oó!oó!oó!oób‰óÚÚÚõõõøøøßßßûûûýýýäääþþþÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýüüüúúúøøøöööóóó¸ñôñÿ¥ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú§ú ™ø ö!oó!oó!oó!oó!oó!oó!oó!oó!oó!oó!oó!oó!oó!kób‰óòòòôôô÷÷÷ùùùûûûüüüþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýüüüúúúøøøöööóóó·ðó óÿ±ü¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú§ú —ø ”÷ •÷ ö!oó!oó!oó!oó!oó!oó!oó!oó!oó!oó!oó!oó!dób‰óòòòôôô÷÷÷ùùùûûûüüüýýýþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿþþþÝÝÝüüüúúúØØØöööóóó¤Ýà óÿÈý¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú —ø ”÷ ”÷ ”÷ •÷ €ö!oó!oó!oó!oó!oó!oó!oó!oó!oó!oó!oó"]òb‰óØØØôôô÷÷÷ßßßûûûüüüäääþþþÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýüüüúúúøøøöööóóó·ðó òÿàþ¥ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú¦ú ˜ø ”÷ ”÷ ”÷ ”÷ ”÷ •÷ €ö!oó!oó!oó!oó!oó!oó!oó!oó!oó!oó"Yòb‰óñññôôô÷÷÷ùùùûûûýýýþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýüüüúúúùùù÷÷÷óóóÊðòñþðÿ§û¦ú¦ú¦ú¦ú¦ú¦ú¦ú§ú —ø ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ •÷ ö!oó!oó!oó!oó!oó!oó!oó!oó!kó"Xñr”òòòòôôô÷÷÷ùùùûûûýýýþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿþþþÞÞÞüüüúúúÙÙÙ÷÷÷ôôôÓØØ¢ðô õÿû¦ú¦ú¦ú¦ú¦ú¦ú§ú –ø ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ •÷ ö!oó!oó!oó!oó!oó!oó!oó!dó!XñÖÝîÙÙÙôôôøøøàààûûûýýýäääÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþýýýûûûùùù÷÷÷ôôôòòòéîïòþÆý¦ú¦ú¦ú¦ú¦ú¦ú ˜ø ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ •÷ €ö!oó!oó!oó!oó!oó!oó"]òq“óïïðóóóõõõøøøúúúûûûýýýþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýûûûúúúøøøõõõóóóðððŠîóáþ¦ú¦ú¦ú¦ú§ú ˜ø ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ •÷ €ö!oó!oó!oó!oó!pó"XðÖÜîñññóóóöööùùùúúúüüüýýýþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÝÝÝýýýüüüÚÚÚøøøõõõÒÒÒðððîîîôý¢ú¦ú¦ú§ú –ø ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ •÷ ö!oó!oó!oó!mó`„ëïïïñññÛÛÛöööùùùáááüüüþþþäääÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ üüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþüüüúúúùùùöööóóóñññîîîöú©û¦ú¦ú —ø ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ •÷ €ö!nó!oó"fòÝâïïïïòòòôôô÷÷÷ùùùûûûüüüþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ üüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþüüüûûûùùùöööôôôñññïïïìììÂû¦ú ˜ø ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ •÷ ö!oóW‚òìììðððòòòõõõ÷÷÷úúúûûûüüüþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÝÝÝþþþüüüÛÛÛùùùöööÕÕÕòòòïïïÔÔÔ£êó —ø ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ •÷ öçèìÔÔÔðððòòòÜÜÜ÷÷÷úúúáááýýýþþþåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþüüüûûûùùùöööôôôòòòïïïìììyìø¢ú ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ‰öáäììììðððòòòõõõ÷÷÷úúúûûûýýýþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþüüüûûûùùùöööôôôñññïïïêìì
Êþ¹ý¡ú ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ˆö ‚õAuòìììïïïòòòõõõ÷÷÷úúúûûûüüüþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÞÞÞüüüüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÝÝÝýýýüüüÙÙÙùùùöööÔÔÔñññîîîbçí¸ý¸ý¹ý¡ú ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ •÷ ‡ö ‚õ ‚õ!só¼ÄÝïïïòòòÛÛÛöööùùùáááüüüþþþäääÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýüüüúúúøøøõõõóóóðððéíí ôÿµý¸ý¸ý¹ý¡ú ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ •÷ …ö ‚õ ‚õ ‚õ õU~ôîîîñññôôôöööùùùûûûüüüþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýûûûúúúøøøõõõòòòðððuïöáÿ¸ý¸ý¸ý¸ý¹ý¡ú ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ‡ö ‚õ ‚õ ‚õ ‚õ ƒõ"XñÈÒíñññóóóöööùùùúúúüüüýýýþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿþþþÝÝÝýýýûûûØØØ÷÷÷ôôôÒÒÒãîïòÿ Íþ¸ý¸ý¸ý¸ý¸ý¹ý¢ú ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ‡ö ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ!còZƒóðððÙÙÙõõõøøøàààûûûýýýäääÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýüüüúúúùùù÷÷÷óóóïðñ†òø ôÿ¼þ¸ý¸ý¸ý¸ý¸ý¸ý¹ý¡ú ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ •÷ †ö ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ pô"Yñèéîòòòôôôøøøùùùûûûýýýþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýüüüúúúøøø÷÷÷óóóÛïð òÿðÿ¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¹ý¢ú ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ †ö ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ }õ"XñŸ·öòòòôôô÷÷÷ùùùûûûýýýþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ åååÿÿÿÿÿÿÞÞÞüüüÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿþþþÜÜÜüüüúúú×××öööóóó¡ØÛ òÿáÿ¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¹ý¢ú ”÷ ”÷ ”÷ ”÷ ”÷ ”÷ ‡ö ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ"Zòb‰óØØØôôô÷÷÷ßßßûûûýýýäääþþþÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýüüüúúúøøøöööóóó·ðó óÿ Ïþ¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¹ý£ú ”÷ ”÷ ”÷ •÷ ‡ö ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ƒõ!bòb‰óñññôôô÷÷÷ùùùûûûüüüþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýüüüúúúøøøöööóóó·ðó óÿ¾þ¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¹ý¡ú ”÷ •÷ …ö ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ!oôb‰óòòòôôô÷÷÷ùùùûûûüüüýýýþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ åååÿÿÿÿÿÿÞÞÞÿÿÿüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÝÝÝÿÿÿþþþÜÜÜüüüúúú×××÷÷÷óóó ØÛñÿ·ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¹ý£ù †ö õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ }õb‰óÙÙÙôôô÷÷÷ßßßûûûýýýäääþþþÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýüüüúúúùùù÷÷÷ôôô¹òõçÿ·ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý¸ý»þÁþXÓúÊåí®Þð7ºúù ˆö!€õ õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ‚õ ƒõb‰óóóóõõõøøøúúúûûûýýýþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýüüüûûûùùùøøøõõõºòõ Îþ¸ý¸ý¸ý¸ý¸ý¸ý·ýºþÂþ ÉÿËÿRØûÓèíìììììììììììì½åï%Ñþ Éÿ
¼ýù ƒö €õ ‚õ ‚õ ‚õ ‚õ ‚õ ƒõc‹óôôôöööøøøúúúûûûýýýþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ åååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿþþþÛÛÛýýýûûûÙÙÙøøøööö£ØÝ»ý¸ý¸ý¸þ¹þÀÿ
ÉÿÌÿÌÿ Ìÿ9ÔýÌÓÕîîîîîîÖÖÖïïïïïïÖÖÖîîîîîî³ÔÝÌýËÿÍÿÍÿ
»ý•ø ƒõ ö ‚õ ‚õb”ôÜÜÜ÷÷÷ùùùàààüüüýýýäääþþþÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþýýýûûûúúúùùù÷÷÷¾ìö¹ý½ýÂþ
Æþ Êÿ
Ëÿ
ËÿÍÿFØþ¨ãóíîïðððñññññññññòòòñññññññññðððïïï¶æòNÕúÍÿ
Ëÿ
Ìÿ Éþ¼üªú —÷ Šöb¤ööööøøøúúúûûûüüüýýýþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþýýýüüüûûûúúúùùù÷÷÷öööõõõóóóóóóòòòòòòòòòòòòòòòòòòóóóôôôôôôõõõõõõõõõõõõõõõõõõôôôóóóóóóòòòòòòòòòòòòòòòóóóóóóôôôõõõ÷÷÷øøøùùùûûûüüüýýýþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ åååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÜÜÜþþþýýýÛÛÛûûûúúúØØØøøø÷÷÷ÖÖÖõõõôôôÕÕÕôôôôôôÓÓÓõõõõõõÜÜÜ÷÷÷÷÷÷ÝÝÝ÷÷÷÷÷÷ÝÝÝ÷÷÷öööÜÜÜõõõõõõÛÛÛôôôôôôÛÛÛõõõõõõÜÜÜ÷÷÷øøøßßßúúúüüüâââýýýþþþäääÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþýýýýýýüüüûûûúúúùùùøøø÷÷÷÷÷÷÷÷÷ööööööööö÷÷÷÷÷÷øøøøøøùùùùùùùùùùùùùùùùùùùùùøøøøøø÷÷÷÷÷÷öööööööööööö÷÷÷÷÷÷øøøùùùúúúúúúûûûüüüýýýþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþýýýýýýüüüüüüûûûúúúúúúùùùùùùùùùùùùùùùùùùúúúúúúûûûûûûûûûûûûüüüüüüûûûûûûûûûúúúúúúúúúùùùùùùùùùùùùùùùúúúúúúûûûûûûüüüüüüýýýþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ åååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿþþþÝÝÝþþþýýýÛÛÛüüüüüüÚÚÚûûûûûûÛÛÛûûûûûûÛÛÛûûûüüüâââüüüýýýãããýýýýýýãããüüüüüüâââüüüûûûáááûûûûûûáááûûûûûûáááüüüüüüãããýýýþþþäääþþþÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿçççÿÿÿÿÿÿêêêÿÿÿÿÿÿíííÿÿÿÿÿÿðððÿÿÿÿÿÿôôôÿÿÿÿÿÿ÷÷÷ÿÿÿÿÿÿúúúÿÿÿÿÿÿýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþþþþýýýýýýýýýüüüüüüüüüüüüüüüüüüüüüýýýýýýýýýýýýþþþþþþþþþþþþþþþýýýýýýýýýýýýüüüüüüüüüüüüüüüüüüüüüüüüýýýýýýýýýþþþþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ haxe_3.2.1+dfsg.orig/extra/images/Wizard.bmp 0000664 0001750 0001750 00000457416 12607337712 020675 0 ustar andy andy 0000000 0000000 BM_ – ( ¤ : x[ Ø Ø 3 f ™ Ì ÿ 3 33 3f 3™ 3Ì 3ÿ f f3 ff f™ fÌ fÿ ™ ™3 ™f ™™ ™Ì ™ÿ Ì Ì3 Ìf Ì™ ÌÌ Ìÿ ÿ ÿ3 ÿf ÿ™ ÿÌ ÿÿ 3 3 3 3 f 3 ™ 3 Ì 3 ÿ 33 333 33f 33™ 33Ì 33ÿ 3f 3f3 3ff 3f™ 3fÌ 3fÿ 3™ 3™3 3™f 3™™ 3™Ì 3™ÿ 3Ì 3Ì3 3Ìf 3Ì™ 3ÌÌ 3Ìÿ 3ÿ 3ÿ3 3ÿf 3ÿ™ 3ÿÌ 3ÿÿ f f 3 f f f ™ f Ì f ÿ f3 f33 f3f f3™ f3Ì f3ÿ ff ff3 fff ff™ ffÌ ffÿ f™ f™3 f™f f™™ f™Ì f™ÿ fÌ fÌ3 fÌf fÌ™ fÌÌ fÌÿ fÿ fÿ3 fÿf fÿ™ fÿÌ fÿÿ ™ ™ 3 ™ f ™ ™ ™ Ì ™ ÿ ™3 ™33 ™3f ™3™ ™3Ì ™3ÿ ™f ™f3 ™ff ™f™ ™fÌ ™fÿ ™™ ™™3 ™™f ™™™ ™™Ì ™™ÿ ™Ì ™Ì3 ™Ìf ™Ì™ ™ÌÌ ™Ìÿ ™ÿ ™ÿ3 ™ÿf ™ÿ™ ™ÿÌ ™ÿÿ Ì Ì 3 Ì f Ì ™ Ì Ì Ì ÿ Ì3 Ì33 Ì3f Ì3™ Ì3Ì Ì3ÿ Ìf Ìf3 Ìff Ìf™ ÌfÌ Ìfÿ Ì™ Ì™3 Ì™f Ì™™ Ì™Ì Ì™ÿ ÌÌ ÌÌ3 ÌÌf ÌÌ™ ÌÌÌ ÌÌÿ Ìÿ Ìÿ3 Ìÿf Ìÿ™ ÌÿÌ Ìÿÿ ÿ ÿ 3 ÿ f ÿ ™ ÿ Ì ÿ ÿ ÿ3 ÿ33 ÿ3f ÿ3™ ÿ3Ì ÿ3ÿ ÿf ÿf3 ÿff ÿf™ ÿfÌ ÿfÿ ÿ™ ÿ™3 ÿ™f ÿ™™ ÿ™Ì ÿ™ÿ ÿÌ ÿÌ3 ÿÌf ÿÌ™ ÿÌÌ ÿÌÿ ÿÿ ÿÿ3 ÿÿf ÿÿ™ ÿÿÌ ÿÿÿ ÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞüüüÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞüüüÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞüüüÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞüüüÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâââÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâââÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞüüüÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿáááÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞüüüÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿáááÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿáááÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞüüüÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿáááÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿáááÿÿÿÿÿÿáááÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿáááÿÿÿÿÿÿáááÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿáááÿÿÿÿÿÿáááÿÿÿÿÿÿáááÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿáááÿÿÿÿÿÿáááÿÿÿÿÿÿáááÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿáááÿÿÿÿÿÿáááÿÿÿÿÿÿáááÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞüüüÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿáááÿÿÿÿÿÿáááÿÿÿÿÿÿáááÿÿÿÿÿÿáááÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿâââÿÿÿÿÿÿááâÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞüüüÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÞÞÿÿÿüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞüüüÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞüüüüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞüüüÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿßßßÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ]]]QQQQQQQQQPPP}}}ÿÿÿÿÿÿÿÿÿÿÿÿ÷÷÷eeeQQQRRRQQQRRRvvvýýýsssOOORRRSSSRRRaaaöööÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýýýtttSSSPPPMMMPPPNNNIIIQQQNNNPPPOOOQQQ¨¨¨ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿžžžNNNPPPRRRQQQTTTIIIÆÆÆÈÈÈRRRSSSQQQQQQQQQPPPQQQQQQQQQQQQQQQQQQQQQQQQ\\\ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿHHHAAAAAA@@@@@@mmmÿÿÿÿÿÿÿÿÿÿÿÿ÷÷÷RRRAAABBBAAABBBcccÿÿÿ²²²>>>BBBDDDBBB;;;ÊÊÊÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿæææ@@@???IIIBBBDDDvvv»»»AAACCCDDDBBBGGGAAAãããÿÿÿÿÿÿÿÿÿäää>>>CCCCCCBBB???BBB………ÿÿÿµµµCCCCCC@@@@@@AAA@@@CCCCCCCCCCCCCCCCCCCCCCCCLLLÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿüüüÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßQQQCCCDDDFFFDDDjjjÿÿÿÿÿÿåååÿÿÿøøøQQQ@@@CCCDDDGGGkkkåååìììJJJAAA@@@BBBCCCÔÔÔ¿¿¿ÇÇÇÏÏÏ···œœœ@@@FFF???EEEAAA¼¼¼ÿÿÿmmmEEE???CCC@@@GGGyyyÿÿÿÿÿÿååå‚‚‚===EEEAAAFFFDDDPPPòòòååå¼¼¼EEE???DDDGGG@@@???BBBBBBBBBBBBBBBBBBBBBBBBPPPÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿNNN@@@CCCCCCCCCoooÿÿÿÿÿÿÿÿÿÿÿÿõõõVVVBBBCCCDDDEEEhhhÿÿÿÿÿÿvvvBBBCCC@@@DDDAAA<<>>BBBÁÁÁÿÿÿÿÿÿ»»»EEEDDDCCCAAADDDHHHCCCCCCCCCCCCCCCCCCCCCCCCGGGÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿMMM@@@BBB@@@EEEuuuÿÿÿÿÿÿÿÿÿÿÿÿ÷÷÷\\\FFFDDDCCCCCCfffÿÿÿÿÿÿ¾¾¾DDDDDDBBBDDDLLL???@@@>>>>>>FFFCCCEEEAAAAAACCC‚‚‚ÿÿÿÿÿÿÿÿÿÁÁÁEEEFFFEEECCCBBBbbbñññaaaIIIEEEDDD???AAAˆˆˆÿÿÿÿÿÿÿÿÿ»»»CCCEEECCCAAADDDOOO```__________________^^^lllÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßMMMAAACCC@@@EEEnnnÿÿÿÿÿÿåååÿÿÿôôôXXXEEEDDDBBBCCCiiiåååÿÿÿñññPPPBBBEEECCCFFF???FFFGGGGGG@@@CCCBBB>>>DDDFFF²²²ÿÿÿÿÿÿåååÿÿÿ~~~GGGEEE===DDDEEE]]]GGGJJJAAAAAABBBQQQÜÜÜÿÿÿÿÿÿååå¼¼¼@@@BBBCCCEEE@@@©©©þþþãããýýýýýýãããýýýýýýãããúúúÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿMMMBBBEEEBBBCCCuuuÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿVVV@@@BBBCCCDDDkkkÿÿÿÿÿÿÿÿÿDDDDDDBBBBBBHHHkkkpppmmmOOOFFFCCC@@@EEEUUUïïïÿÿÿÿÿÿÿÿÿÿÿÿìììNNNGGG???EEEFFFGGGIIIDDDCCC@@@EEEÃÃÃÿÿÿÿÿÿÿÿÿÿÿÿ¼¼¼@@@BBBCCCEEE@@@©©©ýýýýýýýýýýýýýýýýýýýýýýýýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿSSSEEECCCAAABBBZZZžžž¡¡¡žžž™™™LLLCCCCCCBBBCCCkkkÿÿÿÿÿÿÿÿÿÑÑÑCCC@@@CCCAAAHHHçççÿÿÿÿÿÿggg???@@@DDDBBBÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÆÆÆ@@@FFFGGGCCCCCCBBBCCCBBBFFFÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ»»»CCCEEECCCAAADDDOOO_____________________```ßßßÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÝÝÝÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞUUUEEE@@@BBBBBBEEEBBBHHHBBB??????EEEEEECCCBBBBBBiiiåååÿÿÿÿÿÿÝÝÝXXX@@@BBBAAAGGG•••ÿÿÿàààLLLDDD@@@EEEAAAÒÒÒåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååBBBEEECCC???@@@CCC???VVVôôôÿÿÿåååÿÿÿÿÿÿååå»»»EEEDDDCCCAAADDDHHHCCCCCCCCCCCCCCCCCCCCCCCCÛÛÛÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿMMM???>>>EEE@@@@@@@@@@@@EEEBBBEEE???AAAAAABBBDDDgggþþþþþþþþþþþþ§§§DDD@@@BBBDDDmmmÿÿÿ©©©BBBDDDEEEDDDmmmÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùùùYYY@@@EEEEEEDDD???HHHËËËþþþþþþþþþþþþþþþþþþ»»»DDD>>>CCCFFF???>>>AAAAAAAAAAAAAAAAAAAAAAAAÚÚÚÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþþþþNNN@@@???FFFAAACCCEEEEEEIIIFFFEEE>>>@@@???AAAAAAhhhþþþþþþþþþþþþÖÖÖ@@@EEEDDD>>>MMMíí퀀€CCCGGG@@@@@@¢¢¢ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿðððYYYAAABBBFFFAAA@@@HHH¿¿¿þþþþþþþþþþþþþþþþþþ¶¶¶AAAAAACCCDDDAAACCCAAAAAAAAAAAAAAAAAAAAAAAA×××þþþþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿßßßÿÿÿÿÿÿÞÞÞÿÿÿþþþÝÝÝþþþþþþÝÝÝOOOBBB@@@DDDBBBBBB:::<<<<<<<<<<<>>BBBBBB@@@LLLêêêþþþäääþþþþþþããã¹¹¹BBBAAA@@@CCCAAAkkk•••‡‡‡““““““ˆˆˆ““““““‰‰‰çççþþþäääþþþþþþäääÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþþþþþþþþþþþþþþþþLLLAAACCCCCCBBBiiiÝÝÝÛÛÛÕÕÕÙÙÙÒÒÒOOOAAA@@@AAA???hhhýýýýýýýýýýýýýýý³³³CCCBBBDDD???EEECCCCCCBBBEEEuuuþþþþþþþþþþþþþþþþþþþþþþþþµµµCCCBBBCCC<<>>CCCAAA´´´ýýýýýýýýýýýýýýýýýýýýýþþþþþþþþþþþþþþþþþþþþþþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþþþþþþþþþþþþþþþþþþþýýýLLLAAAEEEAAABBBsssýýýüüüüüüüüüûûûUUUCCCCCCDDDCCCgggüüüýýýýýýýýýýýýòòòRRR>>>DDD@@@CCCBBBAAAAAA@@@···þþþþþþþþþþþþþþþþþþþþþÜÜÜFFF===IIIBBB???KKKBBBBBBAAA???FFF¨¨¨ýýýýýýüüüüüü¼¼¼CCC@@@@@@DDD???’’’ÔÔÔÓÓÓÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔÚÚÚýýýþþþþþþþþþþþþþþþþþþþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞüüüÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞÿÿÿÿÿÿÞÞÞþþþþþþÜÜÜþþþþþþÝÝÝýýýýýýÜÜÜRRRDDDDDD???CCCkkküüüüüüÚÚÚüüüñññVVVEEECCCCCCAAAgggâââüüüüüüâââüüüüüü{{{AAAAAADDDAAABBB>>>AAAKKKÒÒÒýýýþþþäääþþþþþþäääþþþhhhBBB@@@DDDCCCGGG¿¿¿tttEEE===DDDCCCEEEÎÎÎüüüüüüââ⸸¸DDD@@@DDDEEE>>>888DDDCCCCCCCCCCCCCCCCCCCCCPPPýýýãããýýýþþþäääþþþþþþäääþþþþþþåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿæææÿÿÿÿÿÿéééÿÿÿÿÿÿìììÿÿÿÿÿÿïïïÿÿÿÿÿÿóóóÿÿÿÿÿÿöööÿÿÿÿÿÿùùùÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüüüüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþþþþþþþþþþþþþýýýýýýýýýýýýýýýRRRDDDCCC@@@CCCqqqûûûûûûûûûûûûïïïSSS???===???>>>hhhûûûûûûûûûûûûüüüüüüÂÂÂCCC@@@DDDCCCFFF>>>AAAýýýýýýýýýýýýýýýýýýýýý CCCBBBEEE@@@FFFoooüüüØØØ>>>BBBGGG>>>DDDmmmûûûûûûûûû¶¶¶CCC@@@EEECCC???HHH@@@@@@AAAAAAAAAAAAAAAAAAKKKýýýýýýýýýýýýýýýþþþþþþþþþþþþþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüüüÿÿÿÿÿÿÿÿÿÿÿÿþþþþþþþþþþþþþþþþþþýýýýýýýýýýýýüüüüüüOOOAAACCCBBBAAAlllûûûûûûûûûúúúïïïVVVCCCCCCFFFEEEgggúúúûûûûûûûûûûûûûûûøøøWWWBBBAAACCCDDD???@@@ÆÆÆüüüüüüüüüýýýýýýýýýÕÕÕ<<>>ÏÏÏüüüüüüCCC@@@@@@???BBB¤¤¤ûûûúúú···AAABBBCCC???BBBFFFCCCCCCCCCCCCCCCCCCDDDDDDLLLüüüüüüýýýýýýýýýýýýþþþþþþþþþþþþþþþþþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿãããÿÿÿÿÿÿåååÿÿÿÿÿÿåååÿÿÿÿÿÿÞÞÞÿÿÿüüüÞÞÞÿÿÿÿÿÿÝÝÝþþþþþþÝÝÝþþþþþþÝÝÝýýýýýýÜÜÜüüüüüüÛÛÛDDD@@@AAACCCBBB^^^úúúúúúÚÚÚúúúôôôJJJCCCBBBCCCAAA^^^àààúúúúúúàààúúúúúúààà“““DDD===@@@???AAATTTòòòâââüüüüüüâââüüüãããIIIDDD???BBBBBBAAAsssûûûûûûáááæææ@@@===<<C Haxe Toolkit Installer Template/UX ‚IRaIRõ PK >C ) Haxe Toolkit Installer Template/.DS_StoreUX ‚IRaIRõ í™ÏjÛ@Æge·‘û'èêCKÏNdCRèÁ’[A† šÒJ–‰De°¤:EuëJÞ¦}…>A¾MWÒ¤u Ç!¤$ÌϬ¿µv4æ™] ¬“º@ T(U{ Q±AA} “çpè¯ Þ-ÎEAÄ
ÃJQÏY÷ ‚¸ÃäóGm£NKe8® VgÎÑP9juZ*Ã8µŠª¢j¨ µ:-'-†›†ßÌp‡Â4TŽÚ¾”e‚¸Sä{÷§°6 ÂàŸý»‰ü¼ !IJgËcŒÁD0WFõƒÃê‹aTdRNŽ¯’k(º]7Mú ?ý¿ŠŒWÈåþ·\‘7ã±R¼¯‚‡¹Ö¡)cõ¢Ëèq 9pdÜ7'
ü8Ñõ¦Tª÷µšúhÏ]1îˆ4tãW–'Æ–ï {ôºè'v’Æ {TŒ¼´ÏÁ~Oˆ@ö÷1zÏwïö$Ëž
n4[“Ï67õo5·&“šªÖ´ êÚ³;=;û8ùô¹¼à§(<žû% ]äì½5
@9ý¯Êª
d
… 7o¾
¦tÞ4õUøzù*,q6W…Š<šB2ã÷û5øg™¡›
n¶Ìe—=÷;½Àð—¿&æ¬ÑúO·˜r5ƒz¾ÿß>ÿù?A·VíZÝüy x†|å²½==–ß°™? éF€ ‚ ‚ ‚ ‚ ®ŸßPKdè 0 PK
>C __MACOSX/UX ™IR™IRõ PK
>C ) __MACOSX/Haxe Toolkit Installer Template/UX ™IR™IRõ PK >C 4 __MACOSX/Haxe Toolkit Installer Template/._.DS_StoreUX ‚IRaIRõ c`cg`b`ðMLVðVˆP€'±ƒøA L… V PK¾CŠ * R PK
Y:C = Haxe Toolkit Installer Template/Haxe Toolkit Installer.pmdoc/UX ™IRYÉCRõ PK Y:C P Haxe Toolkit Installer Template/Haxe Toolkit Installer.pmdoc/01haxe-contents.xmlUX ‚IRYÉCRõ í]sã6¶®ÿJ*÷“LÒ39ÙU{v•¬¶:–ˆ²»kßtÁ$$!¦$ÝV~ýÁHJêÎÎáû*ÉÉìäÂU¾Ð€ø\XX ÿY>mÿ–Ú¢ÖE]}V•:ý×ç_}ñÕןÿ×n>+þõùN½è¿½úâï_üýo¶zùü3û¯Ï?¨B§OŸ¶ý×çU6›Ï?+=óÍ·ÿçÿøÿê}þå}¥]õeüÙ—KgÐi]}yíKúlmmþdêÏæ…Gó\»/?®`ÿ¯Ïk×èÏ?ó%mL®»†Œ¯G·¯§ÉõKý?·âÕ«¯¾ýöó/[$³éÿ«Áí/Ûøë÷ Uü鵪vê1×_ìê}>´Ý¾ø÷ó}™¿ J}¹iÉ‘sê ÕˆQšêª‚¸+?0ÎXEZí噪êyªƒª¸1Ðï =tŽ,m>¸úá[©"³{¨E®®ÍÐ^2:Ïæ~¢oµ»±ö©)¡š~Ûìµ3)UJÿ™Ïû-žèÇfëëÚ9Ñ?6Øz{b“ƦOØznjý~Ó”½ûðõÎi•ÈµŸvàµÎ±µüV«§•ÞÀSå'3tÛ}éÐ]l–7Õ"H¾¥ÿž‰ª±Ž@Mì»&‡Bí
6§Eƒm=<¨ \lÓ•ÞBÀÆ »¡'³?–†îÐ+rù9<'U8-Í£ÉM}XÙè”ÁèSR¤½÷’Šª-ørüþRjWM«y¢•Kƒ@³Ö/ƒ{®e4^¸Dç^">àØõMm÷áÛ÷»üøµ.á`ÔW6‚ZÛnGÅÆl‡Ôwúðh•Ë.ª~a›J_TBR« «²n ¶ÀOÁ鳟«ð(#«²ßÓƹἠÌàŠœãý×dºzªíàc,7e~P¸n©™u~ıUÝÃk§Šj£ÝÂfƒ‡üø™¦*s5|?”ÞORgÊúÁßáÝìañÕÂ>lj^™z¯0©7"p1¶¹uI©R¦^”+ïTQhìÂé©—W2SlÙ–çºÈùg”*«¤>€2ehâØúuÌl·glÒ”¥uØ&2‰øîQÔ<é·–Z™”Ýg6mª‰a>}æÔ^ߨGpz¼v*3~Ç\ Jð¶äT¹3)¶ÇtPœ”33ür|†O‹Œf»¦ Xª»+œ‚~ÙûkÍ¿5…,cŠOv*ÓŽþîÄæ†ïö¤vö‰›akgT±Í5Üñóó]û®”EŠºíæëÔX7Šðy÷åðQÑ“ð8Íéé=¿`ˆEä”ßìž5±áº´ymºÞY¬ŸßXSÔøõf9}}Éœ>œÇÚ±ø»Õ¥
x·º 7þ`KR•kX$¸±²È¼ØXðêãÊßòÀc-H“"
CÔ’)¼ÐECbóZcZ—¥yÑyR¨²DƒåíE³×ãÌœ$õwpŒØÁ3&"ðæ±yQ6Ø6¹7{CˆÔR‰ØVS س°ìÖò^Ì4ð• _RQãsÕÔ5ZU)jibc÷ ¬A]¯&83ÊÍ–PÂ´× ÿ?óiß7
Ö9ÛçúÖº'tf¿1z€ND 7yŽî‡X+?Vt¼š ×5Õú¥'LO…øÌ‹J ö²/`œkåªÂÞ¬Ž¸?2”Ã'B_ÀÂÈ}Ýéz¼}
£áß+á}²/`å; SˆóI‹Ôäœ9!óÆéKú°+"(É"Ú…6C5H} ~yû®šÍÆßE/hÉ[ë€d\ˆí©:öx5th u;HP5+s
ÃÂÀ0WªÂ5ħ`xwö¸vκ¡ :rÛFÞɦaÊ<½1Ex ØÕb¡
:œÞÍ'žUŽSó<×[•ß•:>h%¾b“ùcž`ïpf¡÷Ö pnå—“&0í'µßê 4>‚¬Í^Û†˜¯‰N/ôŸêEµôéîY»Mn?ø¡¨Õ ÎÉaŒS÷EX•~ý¤3_ÍqÈoXfƒuìq·’—ÏÁ»Ušê\;.uЛiÿ˜ö,S '«C‘†$ØQЈz†aý>i6ºª¥ †_v7"°©8ÒßL÷ÉS§;œoeÑûà°¨5jµ5õÎc&¥zë¼ ¿÷Ë… ׿JQäÌó匛ª¶{ÒŒÅóýlRýÚÙ¦äqZÃó5/t2v>°³Ÿl.IˆÖCùUÞy»Üòéñýoé¬És~k]àìkµ×AçH Úæ¶]B\Á¦9§ Þ¹×ëõ’tóK&Ã|1%j¼#'zg¸…“ÁZ ÇnuÍ
ΐ
]X/‰1 äYvÜ5µ_)á.®+‚_
6*²µ*éùÏמ(92¹±:“ï ^4™± ,AmúèjÕÛ²aC Ùh[ˆŽ Ä=-Ì9tÊz´ÑøÆ>z˜•hªmAŒüèÁ FÆfć.)ñÑÕÊDoEVÓYbš‰xš‚Â{ Én•Ð ÕcN¥OðŒýôv˜=êõ×ßüãFDG˜bŒ¥„ ·ÔömK×µßg@o‰É+ÜNÛ¤^4ßYp ŽØ´Ø©"Õ¸{Ú§EPͶÝ;Á¸òEÐ&æÑ °hEψ_˜ôö!'“ Õu¿‚¶WÓà>&íJƒe Vh/D›¨Úáo27ôÚ8ʲµ=y;m¿ÛÏÞ‘ KñŸyÖ&çÕb #GÁ>çÏÇðûo´2#±DA€—Y¡mÖäz|Hs¹?TÞóEˆ8òèOQ9Å£Ñ~@K¸_ÝLì‡"÷»9b¢‰Æ›Þb¿N剿¢RW5ÙÍ»2ˆeÓ¢1rb ØÄÈ2åÅ!¾ËAm˜y…Pj Ö[Ùñä©ÀWï°E•:5ƒ>?_ÞY ñVü[P7:Kös TX·ºæI|gë X–ìÀ•Nµ8Ö¡á‘/óö<ðg¿6m±ã²+'a¢&œÂÄýëø2bÄ%ª§Feé›{u¨uE89ôÅ0# É…ï'?dUÍ!§s8+ H¼/$º?wa:@uqUÚv’ƒØôIæÎ_•pwíS0D\#ä_¢½^T ¼Ž{JD:ÂOÅó+‰@ 3GìZ3mnaBö0±xêA9#±°|·¸ÁƲ=Jg
‘x^3–òsÔ9·ƒ(éŽ=¾9ÁßXK!7ô&UL%1X£/!v®M´XüÆ ™ÀòÍ2ˆ86„°8xÿ·ÖVCߨD§» –ÕÄžöîŸÿûÄË£~N7¦ÚéìhrWÂœ´øÜ¢œªNÝ0!úh°Š·ñPÕz°n¡ì¸‰Ý+F;Ò}€ê‹ €å@ÑKX'~.3‚á…8q
ŽUÕh°m}èõ¨izkê]B8ËÏ*xÎ^|åu”£–Ö¶ÇÍSô÷b!ÖáA–P,¼j–'þâ/ñ -ô9Š¿*u–¬D¬æ]*Xß ¶ ¹/3[뜒¸9¦htªà‚ ³D˜†ˆƒAhÒô'€Lò¡û¿—G¹QøÃþ8YPO_ºØšBlÞ•—³ŸîBl¦@—Âx6»Ž0†E
õ4Æ6s±‘£î zk20œØÔßáG•QÅ›¦ªqe[û}Ämæ;h¢«à† _ô,KßcþªæÐ0ŠÂ-m»í ÷V›íÕ}† oÌÔ‰^qØŽ~§„C
4¾Ó®@WÈÙA s—xhg
õ7¢¼ñÅ£ìH Wn¬ÕcˆCŒ“Úbó\¼$VlmÀ M´œ(ˆ9' Ù›ž¼a>N ±?
H“ ®ˆ…¿„•ÞÂ“Ú $*z ¼²Dz*K4ÙTc¥—d ƒ7>|Šˆ‹+QRqÎì‡Jâym£ŽyTûÃ㱩uˆWÝ[äâ’&0»ˆo&…Cÿ‡HvÔßJ=ÑÄ Š=ÙFMƒ·Ö°‡¼ÔÌ2äp”„êOü£©"$¥#†‡²;²íÈÀt 3–¸n÷û%!t…Ý. ÕÄá°jðn’èžÕŽÈLRûˆ5#¾7C“M„ºÀo+‘»jLî]"¤‚
Žeô¹
.*ÒÚûös”TíÀüj ÃøùÕí’8væ¥YT7ܱרƯó0¦ ¸§¤c4šË‘·“Ç=Šáä55%mˆÚÒ¡¦aÇ)ÜR °&ºàá
}0è¿è‚‡$îA}mˆWaØ_ÚßпÞ]`–[°7vêeèëÉûiÑìg¹Ú•‹ûß¿— îïá¯y]×CÇJ^‚j²ãÞ¯µo¢ª‡öÅô¥tkû¤Ñ‡®X‰ÐˆTÕÔXåb²
”¤îPÖvh·g¹v¯0ͦnjáXU.«YdÿD°¯à.Ά®…÷¯åL5iÌ)2—w`@w²ˆTµó7®u¶¿fWl” †W“Bvž¾èGžñ òFóÕœ ŒuÑ H©NÞ‡è¦ÿnýž4+ù•ÊC„šµÓØ&!NhðÌxß®´±F>Ÿ¬Pl—&`Í ñlS¸Mp Ô†V$ +Ù‰‰víàúÊN€g!²î|î⨈IèLSO|óˆ0CEˆ˜
þ÷8«Ã9غ PägS»Á~O¤3ƒ_m‰÷Z4#{Üy ¶õëûMns7³²ß«Ô
¥Û üz_Í0¤°¸ë”Èí8d
Ð~ ö½K–Œ>á°Â!`ßP_("ë¾4¨+nLSõBUÖrøé3¶âõËeà €ôþ²p‚à Np¸*2ä¦ezâȉãÀ#jÒzÂÇ´¦\Ë}›ŽW²
„ùÊÕü/å.H®•øbÄœ
±Š-±Hä˜^™ •Ea†Û°ë í¶<”¹©©ÚƒÃû3A†‡$œŠiϪ.r“Å+–) C I|Ýî¹— u(§ÍuA1w›„Îm7±\àN¯»*5y.bÜ„¥L KB8ív¥Õ¾UÏ:Ù©’¨ZÐ5"W Eég|;`Îè+åà„ebtÊÕUi i˱²_ ˜„£Wzcÿw|Â^å £÷•ÍÔ÷(*DÌaÈ3ᜠ»(º C‰Æù²TN ül_c)aÆ“Ñz”0&;%—GDŒ1’W¨ÿƒo
}°R²~[€W˜¤Ø!˜. 5SaQYð²Aî
Év™ÈÀ cÌØ6°â8¸ cH’ÈÔ¬t
¿x4ÊÁE
F}—ÎTª™jç{É\ÂßéÃF²]ÂV LóJÄ7¦º¥?%)Ι½é}LQš©Q|‡J’C,0ý¾ŠïÆ-Ï4˜ ÆáÉ>jÕ¹÷ÅSa?L“©ú„LSÕvïÊr,JeTz Ïƾնjø†¿X
€ÕT¿°%Sbµ•œëMLN‰p1²v›F_=_XîüôIrR¶ˆ.óÇ
}jšËë(A}bž)ŒžÜLpÕš9µ¥aØNor·8I<9VéæÇþ¦6}I5îíîaÂãn!®@°Lî9yž £I¬Ÿ»ÅÂìq¿Í=îaâ-Z¨¼Ù‚JØž¢šÉÅJ `]‹¾%DæÁ÷q_@ð[æIôÓƒt[ïWXœf`Oìbv¬–Ë?&Ätÿ¨3ªÞ¢FCG„‹\vüì" nS (õÈ7VÜZ¹-( ƒŒ„{Ÿ”’0 ¯¹©6±8bâA€¡9îÕ×ø&ÀoþA€¤vVQŠ“û4
’Óe3Ôã('ÂFFç(<ò=NL¸X¸ni±ÑõÞLXc OÔ#F}ßÿ:¼>9'¨údë A|(z
ߨ„„…ï@QÇšDÄÕ#F÷jÄ©Â,ç>ÂèG nðEîýhcûwOIÁU*ìÙ¡eàãüµ¶9“FËs%U@¢Ë‰õÖx#¹ö;9sÒ 'Ö% êûÓ‚È5õ†y½^ÜŒò|lsæÚ'4‹úß²
Žáø*²f“
u› C7ž-"oM½ÃÕÄ¢8y„ó²·¹÷«ž˜ó"ÓØÛ š¦Àÿ Ï€#A&þs@®ÔÅ䊉bÍ0A9®ðI~_n@oµÎ4ayñ äÉc·Ì3œõdšÓ÷“ù
ˆ X(ªœë¯¾Áöޒ¾ũ7êYEÃ/E ¢«9Ø?àÓΓ[MäܨGM G7Ú×H‰7sŠ2ÅÅQIKUÉÔµPίxja„'÷Vo‰Æú;µÚ$@ø0?å. á HXÚÔ÷v‡ QJ™`qeæBｨÛGJÂ7nT•ßÎ[ie†3€K4 ¸Üõ¸oô×Q
´Ô ò,ÝÒÔí#&qïî`¾Ú»ÇJ;4þA¯tjAÛ=I¯šÍrðq(Pb¾{ݪg³Åƒß£Ø.»‚qÑù[Ÿj"^=d6†8OOÁ±†
Oñ¥v{rYS‹$^~˜%}ÇšRøKûkgJ¢ˆ~Š ·)Òï ¿(ñ}d¶ô²)IAFøpï#mlÅ!ÊßþÊ óÙÁ›Š}wI`Wô%÷„kw&8fÚ±„µÙ› !‚gmôc›ˆ‡=12î’Z³ ŒË›g$W·£Äù£Ý¼¨j×Pñð¶âúEÖ Yxœ¾olM}ðJµnŒðI„+°Á©ñ`†V‡Óû?‡[=5“V¯¯ð ЮNªlE‡Ãˆð' a#B¯«yê{±ÈL†ZQž‚xƒC„ÊïDâ>wG^|#ÌÝa#ëUô:ñ|QÓC ¸Ú ì÷þ^B*+þ‡2¨IûiYIqG‹Ø•¡5HÀ]uãå8õ" pŸ Hæ˜ àJ—¨Þ åªÒߎñS§ÁüŽQL}bç:¼AíËÎHÜe9Ø¿R-©ØywS WNAÆù!*󈈧 ¼
F˜êßRQ—ǤÔ:ݽö²Î ŒÏ~Fâ_èøH 7'0/óšl¼¨Á¶D
‚OèQ ‚ˆ‹WÜeágæ§EƒqR=$Ÿ”Lõã/üô!š6, NÂæìû0‚¼1IŸ' ]uOì|!‰ŽAö,Z¶4/籶'Ü¥õþ*‡'ÕG,mQ'Æ%¨%BË[Má÷²Žïí“BDw!~\È}xŠã
ñ%8ôsò…€á"„c¸/óÀçÁ)\¨syý:?”»‰Þ\‚_Š1Jp ^3¢.Le ¼PgtÍÙ•µ¹ƒ¢v¬dh`¼;~îo
h( Ž½ÑÅÌÁpŽâÑ[ü¶Ù?’Ž(]óÒéð¨<ªJ½\IÇSåÀšÛŒû"…ö‘د¿`y´~î|}ã/
0JÅž1.åÎ $YG¸ˆ7¨r=Äó)Äq°
ÄÐåM¤ªöÌ\X„
N¡J7×þ *Œl™ìãµ%[ákëÌO^Qù¯TÌEŸrü ïÐ ?¤+„n ¼±naŸù‘Œ0ÑâšwSàO…K› ¶œXÐœs.}'|•_" ¶ñÜ ¢O†0áí±7`Þ®’ÓR$µ¥4dPOyㆅ]þýþºÏ% Œ¤ fÈÃþÑRñ$15˜I]¿ÔdPœåX94°Ï©ÏZ›š› ý{!GÁ“–\]“5k{_˜–›÷«9âõž{· ˉ&ƒX
É[» Ù4ß 2
ëmÑB.¬±¢ i#¯sn×
0¹ã Kƒ+î¹(°m¦!vƒ6ÓgØ¢a{A¡Ú Ï)~žànT=5ƒœ‚øÙÁ8iö:8X‚C ;¶I1=F ˆa ïŽàúÆ §ŒÏÜ%îïk§õ[•£N1÷s¼ª{ÃÅ㎠È% ‘+`ã\íK4ñ¡Í™C Æ*7™© œÉþÁdšÊÅø`MF™
ÐÛ_øñ¹Ym*OxÎGÜժ˙ª3Ù§“Wë1XBð #ßC[šI/óØlãÝXãÙ1-f"Úaíè²Þµ]Ówë‹Ê£ÂT¶v¶4`”bq©Äú5–‰âÆVšñù»›&½1Z¦_îQ-”ç“ö…}¢y ]Øù"ºž–û(+êEýö¿øð *¦ìÍ3 g11¦¥ÚŒ³Ÿ@–N§F<¢£Y ,i¡+Çß'ÃÅ— MøÉ`ú†ïDoõcbÓ'ÐÿâíN3A"?]ÞC7’TÏF” önqs]×%èö åŒOÏËàÿœ—s_úݳ_õ$~ýz!æ'pÈßٳʼóÊu\DƒÀ@±·‰üæhмÀ.±ï’›uŸU ^öo~ħě“@®u^‚½rc°¬×I*AÆÀW &rzòvFœœ² ]¶ ¨µÌ0Ÿ:<8 =qÚúɼ \¡ Йr¤.ü
9Â…¨ÐõÀoŸ„˜›7Ö–‰ÄLÛðÔz¿Þ9²XÆÀ
cUr%•B¡*ˆëÛ¹DW¶ß_]òíËArøù!Æ>ï8pD¯¬ôÞJ• qõtá~]ù«ˆÅ¤ùçýÀy2¹»ÃaWÅ Kø¹ö_
¾Oy ˜e34IrDˆÆ-šL-'
[çàK™an0P?™¡»k§?ÂtySa§ã}‘‚É·÷ßÛ€Ûc¹Úða RîÞˆ7¸6ç£y¿œÜ
U4æ9²äJUš#'W½˜ j½Å$ ÿed8Orí]^//h°<„£àñTŸÜÁ½“+p1z(é‚ÀÀ-äî‘× ÖÅû mý…}‹jüÿ ÁI•“W¥„¸¹‡ÇQnÒ› -“;p‰.ŽÈU³!¨µµàA] †&1}L[8à;S î±~d†Ÿ"‹
“Ǥdr ,¼“ /t1ñÂB¥Î äǼ‹u€×çaÒ¯ÉH¬.Ìi€ù®aD
ñ{˜ÁJq¤CÎj‚Ãïï§3‹ W:ǵð!ÄI(¹2Û9¸G ‚Z½^™BJÔD‚ Ä}«NàÌoB€ÆÉBˆUFMýý(£g$Ü #f¹Bµ>øl‚Î1x‚ÝX/“Lb·5{¸ºˆÝÃÜ~²ýûØ'ð7ž Â6.1p0³$Ù«ýyn~Aqsþó_ü©_dÿñO¿Èö6û/ÿ§ÿóKùïĘb>žÞ&Ó/ê—_X© é¹êlèsCÔ¦¾ ~+‰ÚìÁ¿OË¡Ï6ï‡7:Þá·aº’ЃþËÓæ¬!ÙÐãs "ðˆÚŒ‰²ç`是]|€zº‘ r_o¾[Õ+¬ïÏàÞ
šçÁÌpýñ©ø6¸øÁÂ[’—{"ë@Lwô†z‘éáK<Ô‡q{¤mÍù>¸šx¤
þy84¡š©ª>¦Ö \Qx_üëá£M›°ÅÜZí n«k3x1è¼ k~cíSƒì™¾•ê&%Êè?°1zl¶A;?¸YÒàß‹QÒðIÌ„ÿ¼5ÜAvÉæ…|ngé3 È‘ÕúV«'¶€ãËØß Ÿ„Ñúføizb{ïméà'ÐßNŠüm¸°¦áàÏ(ö}ó‰FÔ€¤ø{Èp }ÿ^Bß UÌŠ†ƒÃ®ˆó_oa ÔVv´Œ\¿tïùƒB"o`÷¦¨ÃÃ+¸¾§/€Ð-ÂhK†®«H!+ë¨ý„ø3¹á§¶Þm˜ùØ1€ m°"x[7y5¬B ¼B p£#qe$ä׳øÈ"Õ¤þF
…K&ã A–üÄ$<ù§ÚœUÐùÕQƒ;üÔlª²P]LŸ ÍB†Ë±Å³q¶ˆv½Ã©£iîðÎk¿È€} Èý‰þl°•4x秅&PÏĨ8þ|”—eŽÐI¤
P>ƒ¿gòbCHÈ2!í=¢Ð{?@0&¯¢wÎl
2»ñZ°Ò
›Ô{ëÌàáxlÛTåb&¹1u’C’%x˺+CBÀb ß=–¹ª%’Ã|‚œæ°./Þý6X…RTµkdɃ+d¡ëÍ®B
dkZ* ûRk …ýä¨Co
bFˆÝqÞJR™cT€¡2ÁJo‡êöήquPØùF¬Qð à b·¿íªÁGæÙ×€º© DG@hõ#?ú¿Êl“«j÷ëëÿzyýe=4®´ÃÞ^·ÇÔß\7£‚\f MnêÃà Û ƒ\ÚN¹ù¾ŒÑ³(‚Ÿ•â%êRÄqHBœ'Z¹t'÷¦h€ Fš-ÔIÀ¬Ã›ÚƪÀõدuk…F}U#ôBê%…Ù6 œïôáÑJÎ0¾ê…m*}ŸÔ!Sz£oQX
ç·Tr¦¶Hç|=Ãe·Ì ]9üQñè5§«§zpÈIÌ ™[ /ÅÈÊíÑ.éð[ÛñCöÎá{ôyÌ. É>‘~X|µðw~d"^™z xèžGC²×6cXDtú! ñN…F4Бí„p®Í’¼µûõ]…¤ÐVè7¶ÎÁZ½È¤)KëM"&š=À/gœDËS¦€.è3›6UÔaŸ bvÞ¨Gh2tÉI@aÇcå.놑8ýfz5éài‘‘d÷¡$¾ÄÔ§˜ß öª@véSú)À»rGÇ8šä÷&67lWû›ƒ}bfÓÚ%>[`gÏÏwá;øE²-`âÔT¡/ >Àóî‹Ám¿çÀ‘™“ÓxN©Ø9Lã°Â–6:*GE@¿‘§<ô y³œ¾æçÐÑ7Öqð»Õe•¿[ÑÕK¶³$U°¾ û¨îS2aû :œ‚Ô'â*üȼÐECAsPGm^tžª,±}y{Á,õ0=K’Ôß‘ßïÐg‰ €Ûa„PÃ…H½±ˆ
B“ºÓó$(g} #±š‚v媩k¬šRôÞð&í1©¤ƒŠ ýý+ä (£Üla…G+ò'5¦eì÷5ycvì v¿‡SogøÝ»äÆMžc; Ò¾Õ
¯&Ãõ9ò\Mž wß™J1}`sœä³¦`¿ù+‡|/LÓB0pkõN¢’® Üûz<& `?:©u‘šœQÃÆÎj\R@›È€( ]N3LKÓó1?AÌÛ·⿠€ƒ²sÄz¡ÅÖNˆ©c/}C7ºÏ1¸I¯†GibøË¿!žøÐNìaíœuC»q䶼$MBÔdzcŠ˜S %W‹6JNïf0‚þþYå(3Ïs½Uykñ‚wȼx–Uþ †É;”ˆQ(r×ÁP—§ãƒ˜1Úž—‰N/šÂŸè…«ôéîY»Mn?Àð¡¨Õ JÉqŠ2÷EXu1œ ¯æ(â7"³A:ó¸ É;àà](Mu®
W,à±fz–!G¹êP¤áÓ`òA”!¢
ÁI¿÷™®j)§—Ý=Gk*†ƒÃ6=5H·²‡hXPTT 0³ZŒšzç!“}tŽû\Äõ\ÿ
Q³Ì—2nªÚî)C
OOô³Iõkg›’mÀi8Íֺеʸñçf9ÕPê÷¢kP~%A7‘@.w˜ix‡DÛ8ó~þj] äkµ.H0¨mÞ¦ÃÑ
499Åн^¯—ÜôšóC?_LáÚî¨éÜ™ ¡\°9B¡[]3¼Çâ5ž ÖKNx·x’ôèY÷QÞ8àí¡Q‘UIÎr¶æDɡnjΙì
ÃASSvS³÷”];ÀÚØ xô¬L®¢M%܆¾‚$&e""/Èœd„ Îìœ%{9ɪF¹,Âsç4ç9 ã9ëö䪼/RÕlw5µF>…‰šfbÞ¹ns[a°`O Þ– öx‰|ÝÙãσÂf°²µ¯nΖ¡—Ö+ÅÍaro>Åcø›Ó)
.«¼q„ê<·n¡jg^µû³Í™p0_òÒ`¿ zùgyPg>ñ·59Ìì¸ú×9µ†qÜtìhªêÞB
÷EÜj;ÔÇ=L¦~ßE$Ó0a zµ¸s¦óÃÀ^Hü>Sê`_åµ `cÑð€yø`Î:䈪M^A=ñܨáWŽmn E
Š¸ƒH|ФCÐ×ËàŸ âk ¸¶ìR¹.{¦7 ! ˜š;öÖßåûDáÚïu,Êݨªî ^¢HŒÐâ!GãÛP“Ê'fkê
‘óp ääj)lR/8ï,ÔóGhZìT‘jÔ©éÓÛZÛ@Îá÷¸ÛWÄüç!‘T-·ñ=À ó‚Ý b$Ç£*ìb- ªAŽB»–@é„^ÇȘÁÚ¨rx¼åÌ
Q–ek{òŽØ~ ²¿ž½¥Â¶Ê?ó¬ ‹¶«E€Š´p?B_A»”‰Ôgp…Ø9}|HsMDÛòˆñèOB9CÅïÍ~ÀøûÕÍÄ~(r¿_Qcô ]´Ñ-ôkT â*áÈþÜ• /ŽŒ‘ ˆ¸?“C¡ö&mm p¤U Ì+ŽêíÃXîÆ@÷ãæSêÔl ö{i}\ ¼ëxO=M¼Š¼^² ºcu(÷uØJ§Zœ±0ùíH—y»» ó¨Ã¥$¸Wü)
߇Ž¯Ò_kzfT–¾¡!©)lPß‚pä¾wü U5[€œ/¸|~†ÉÔ EDX"¥-@W:yF×HžNïüõuÖ=ÅBÌXN…[êyØû´gD ƒ} <½’„Ðq„®Ñ G–V=
/oÏ<(gÄ÷ ¸w‹4MàJgŠzxh½¥ü s×ìÂI¶#ï2à×UÁþÅ
½Ý”ÑùH¦²è{ÅšÕb…×h4϶¿$‰bD ˜ }ÞZ
}Çýè&Øø»ջþýï/9úùÛ˜j§³ÛÁÍíøÿ8© þТœsNÍâQ÷hR‰¶
>^öB×Äî.÷„þG9–ççpPr€uâG1Ó*xž]Ã'ÚX•Q]Úu‡žŽš·¦Þ%°£ô,!žìÅOZGùgi}ßCÁÖSì×1R¸h0ÀA•`¬º“åþâ-ñï`î9ˆ¾¿tÖ–¯Ö\*PgŽÀ}™)Ðå”CEƒR£w„ñ# wÄ€ ÂDu y™n”…>j“ñ@¤‹)†Ö½òòðÓ]ˆ ×Ø” Ïf×QZE ¨ëÆ «Èæ,VcÌ 0oMvšú[ô¨2ªxÓT5ªÐj¿ ¾EÍ|·LtÜ3ÁÐvžÄ3yÈ_Ÿ ¦N¨¥@Wm¡Þj³ÝaÅ\ Ÿ&ÑŸ
ÆÚ±îÔ\˜1ÂwÚØ*¸1Û Ú oΑꬩ¾D”%·Œ"0™µ°V!f 8 Kj‹Ìf±¢—H mAÀr, f0؇g—PTzîÿ(AÆ~_§ ]ºF,áWz †·iññ»ÇÎAW¼íÏT‰ˆ!ÛÅðãá˜k×bN| ' CT"L¢”Ù=õÅûÖF]mŸÌ&D"@îr™È
’Z„-“‚!ÎC§';
iC¥Žhâ Šžk#W›eØ ^j|{™ÿFB’'þ¶Ì°D·À’ÍBˆ Év,@¶³ _uû=‘ Zx£_5hçH”Äj74¾ûñââ;eèF!Öwè–Ú Íä} ½ADJ2 úa–“P¸öc }äö Ê \öÞÜ #Õ: E þEO¢¶6 9ó2'¦cíÈkL“ÖyœØ+ »´ÀQ)%îÜèïÇ«°8DG
´¨
ȵ¨l(( ‘ù ¿–¡êŠC
§;튰“o3õY¯TÌi‘]ãñ ¾s^t'9B_£aœÓSPe¯©ù 9þ&¹»Ežïü>Sé `#€ Ã)&7÷ 2M¿_èüupúeÊÒQ {Vyp$‡$ ¹g×вê8 Æ+}Ùuš~·¸Až?7›6 nÁS µž'n1y¸%Ь_‹›àU…ôgÖj &í,_Èh÷íÀqRÚýYrÔuæ¿}ú86 ˜- ;&íw-ù].3XÖ*4ŸS?žA¥’éÌËÝÈCØ_!.:ìOiâO%â îáC¡ï0lÁ µƒ¿‰‚ܧyίVBàcz¶Üî%÷;û¹ô³ç·Øø˜0ïó¿F†4oGsÁ<%Á$iò‡™ÏavaÇ/ÔT 0-¢ßÅ°WŠc^vöŠy7 8âm t:öNÜ}µî.“c•‹Ù"dœºCYÛŒ²\»Wˆ^NL,Æ`¬ —BU,²bûÖWà ¾£%s‚åE½Ryˆs°vé¤iÑì TÞhì‚ Ro›$תÚaý.êŠ;Ôî
Ôopª¾dQ¡ô:Ëd´) G(e]ƒãøÍ?€ß›¡[IL¦‚ª¸ƒ§$úûXJ¡¤…¡>VØOíù5œþ|u€ß°œ©qÍê—Ô›
Ú n,b¹Wþ 5ø
½/
æPS ¼ˆÒ]á¸ÇÄô%x–½IÂñ F䛾”èÏÑ/‚åÀð%˜+àBÆÔ1‡«ö>~9jl…M—~¥,mU´Ì齜NG‹uIaF™*±~_áD?6[ G_T©šðeÞ#(ÕõDçê 3ª‰rœ‚gò8÷¦¢Xrø) 4òZ9tÆÄ›$UUD}…µM!£°JÖÂô+R®½'o‹lÐÕõ`“Bp—•t8ØK$ò¤}Ô ù›ZH,†@ø“ s\Dm,Äåk`Ï®u…º_ Bø Tb
[€]Uµ©DÀ¹—€ øÐÜ×›oŸÐ{¹Kd= ê«þDZŒwR0̤KƒMD€ýµÿÚŸL9ðk§fqtí/¤{ÈÒÏKg²ªç~qC£ ¾¤ â)9ëÌXd^Ôó¾jü ž‡4¬uPÓÐ ¶½NW¹Wþ™l‡P
Ó1&¦BøM“â§ÃÀUƒèqªÃÐá–×Jøùh°ân†Å.ž… ßx CÆŒUì·À™4üíøÚBGúÖsúð÷Û)p«8к-(Dó©TÃ1¥ÂS"Ë_¿ÀïÛóéªAtâ(ôÒnm 3ì¸çL‡j ú 0xcT ÏðZ²ÚÉt±"ô°÷,1dzÖòûÁr²r_}ƒ½Ç ¿ xé8Û„~úÉYÿrV?¬~C{ÖΙ šÐ8ñévè]9û»ŽýéeoØÕƒïÞ£ÇJ¼uk8Ò¨HwÖá‘*F…Ù£n='@ï@ÐE"Ôi" ÇÈiÅP~¯ƒßO¨£‘`íø¹’t?C§“—æ~vƒî?!£ÞGJŒ™ 13•:&§aÚŒ¿«´É“$†e˜™L¯ÁpÂÈ
ИÎ3pLûB’'ŠW2;ÑU.85†WÆ àY4ŠÑ6ðßB»-Ë&enj¢æàùð sáqebðûªóp¶h¥2UAd!©ÈÚ]” ÚPJ7.än³‘OíR³æº«R‚Õ/eš PB¼µ« ®òzÖÉN•pµ®‡_eŽtÒ·èbÇÏØ+åÀÀõbŒÊÔSi ÇIJ ðÄ1WzcGtb^ååÿ•ÍÄw&¸=âÜXϪb¹ÎQ
—aè07Máú€y„yÆÏð5Jx<G nJ²SraÐhìÉk…Ý
(Á÷aw ÆVpNx Ç ]h4¼²¢²¶Ž†ê/.ºým¹ƒK$‰LÁJ׫ëŠ$‰’^0…Aß3•j¼Êù^"ßâÜwú°‘`üFÁ/ TMü²• YÔü™ótLN[1Î[› ]!^XæôŒìIr®€.‚ì
{r˜œƒzbž ˆœÄx€ ™9µ%QPI?¹[œ$«tÒccꟓ1u‘ñˆ¸$ ¹Gïb¿F^#w‹…Ù£Á”N(øñínÙ “7[H‘Ù3D·õ€Õá~mŸ4úŠ xxb9ìÏcd+ïWH1Àùañ}¨%ÄÞI:Ý?ꌨ³¨±hN`‚D„]=¨ß3Û\ ‰ƒÀ%¨õ} ÖÊm!á5ö$Ì+ a”®©´§=B‹Uõ«¯ÑM1`ßüÆ(í¦ %÷X£¦Æf¨õÆQšÍ¹ÏAp¤{ž\ ‘`½ÒV£+â•ížð{tJ !â»ìW¡uÉŽOÔ%Û‰¡ß3è$ (†8š({å#Död„‰nÓ… !²©›*^jË»E°föï~‚½Tˆz¾%ÐÌñh:ÍŽêtô %‘Oäm ¿"H’bü´Jì%pÐ÷!–ÅöšxÅ»^/nFy>¶9~õ–ë}Î5µÍWLÕj²¡þw£röFcóG@r‹¢JVQP<‚ÙïZ„ÚÇáDÊó"ÓÈÛ…ÑÿÍOÔfföŸQ¥.&WxH0œ
e…Nåûr뼈x«u¦a‹‚‡˜ø•ÛÏ`ÎétNÞBŠ\ô÷ J/0DÓÄG‚Á꯾Aiá÷Hñ@™7êYEC% €¬ãÝZ
oûèóÜVf%7êQ‡ÊöµÇúÍœ`LñDPDŠE$¿\(çW31ùÃãr«ÿÃb"ZÂx— Ÿ\4ÎãÀrp`¾o´;\JÁh‰‰*c’tÐfOâË3c~Yp|ø¶Äb?Ê}‹ù6$0Kì[!ð3ÜMÝ>âÁ·Ýe«¼{¬´{Æær‹®tj!Û2Iƒ“ÍrèÑ$0b†‹½ÝªgIþ íD ±¯ü ŽC/á¼*¸eÝâ9^=¤<>ÅÆ4};…—ÚíMÈ F,„xÁì g"à/ÊdìxÅ&¸àñKp~uoü¢Cwˆe؞˦¤D¡ÃÝ‹²ñç™mÿÜàwC`¾“$h"ö‚yBµ;ÅìÈ¯Í óéD“?ø±Lü– NËVH¬ÉEeÂ3Ž©×böÑ÷j^Tµkˆˆt[q¢jŽ$82ß7¶&>t¥Z—6ðDAUCá÷ŒZ ´oµ$½Ÿk¸I³fõú
Måêt ÊSô$¸p}BÁväÚ™§¾ïŠÌd˜eß)†65D<ñUƒïUPÔµ3¢Ì 2’’ïò?B/htàQQ²¦ïý]Rü%ÓóÓ’’&¤¡cŽ l~ <"hÌs;ÑUPß]
M—“œùäÀáGFÀVºÄnë-U•¶ú¤r ê”:¡n
½I|Zç*ºÁ,¢Î8Ô=5Øam
ùÖXn…ÅèˆùŠà˜§nP Udp„S ÜÜ"Jôi©ˆK\Rjî^{ e¯ <åÐ/ l|BŽ1û K5[”LÛ5Bø„ å!ÊšxM]R zî}Z 5 'ÃðI à`T?
¦sÁ:qžu(c‡†üžºÅH?'=oϬìt¹ÈÝ^v#R*,+•q¯ì'Ôeuþ
Í'ÐG$iÿ%fØ›{KÀÛHÄÀ—¤Šíá“"D[Ê}\Ä}x¢bŠñð3²`ár‚B¨÷êB7ôçÁ‰Hˆ`^yý:?”»‰Þð0OŠó(”
KŒõM:¨ŒØp:#kÍ®¬Í5½#%îsÚÑ’¶ ÍÒ‘7ºØBA¨ÏA4z] ß6ûGª¹$k]: žUGUé/z+él¢PÚaptÈìý๯¦AëÉÌâ}³/ÄHÄ1.eÎ Ê" ݘh$˜r:ÄX)Ĭuªï:U‹ZÆÍ}C9ÇWéïâ´M{dÊ øTø .±iî§
‹‹ò|l³PuI„*ya1N#¶ ³éUNþͦažÇ(, þÑ´§ © ³© ƒòß01›MSùI²ÝÕ”sƒQ•¹JHÙ+†"ü\C+(ÞÙ’UYΦ³Ü2X ôÛ !´FðŠ_³ áT2›¾VMUU\å
5¿I;ìÙ4Äú¤AÑ“S°uåÎo ["pÈlz·ÙT”ô4ØXÐó?ñÂ_“‹¾–_ÆIiù¬
#¡x®qM.Þü”c9em¹>¶UâwžL¹Lâ4›Ç‹À63õÚJ, +‹8Ë°^Ý1,OÆl<Ë9ˆ·tâa«ƒï¡üàµÙ¬Å ±Ó’
…€%FF“ðÂûÎË^¤óãÕQl“RA’,|‘§.ð7¦ÐÊñý(<é &£Y(yëd B*Â]OØù(U™`G.žwË…6”¢f©@ãIê[„J $+-1réè9ñŽÜ
20k¹õL3ß¡{Öµ 7†kói\ãO
HöÖÖ»‹Û‹¹¤5ß7*%ëE}Òò«´äò¾ù¨(ªU²/×–jED¯3?yñCå¿J!|Äèƒv¾/ú„®²àv¨…}fÇ.¢p[kJÂMãM> -m~Ø2ºTsJ8¹ìUA̾UÎ T°U6#Û÷ÁÜç!d7òÊÚÿ1š¤¶„F
„(/¼ @ʾZ?7«äƒ©SB4JûGKø“Kr(ݧ~©éøïs'/²õ}¡ôEkS3#ß¿ 1 89ÙGÆ5u_sfš÷…©Ñ,–÷«9óžyÕÝG‰NA8mÄ[» Ù2P0lê¨BƱ"Ý*#sf/
(µ‹ Ib+æ9%mžn_Îe .hÛ&ÌBû£5EÏÔ
§gÆPP©S Ýô:åÌ^÷;¨KÈÃÃ6)¢7¿‡Y ´‚«sâ V¼«óÚiýV嘓Åý æÞ0±„ƒ! GC
Ð8WûRg0Ëùð·¹;ˆƒTå&3õ!©1'É“i"oÛƒ5a¼úA?n§ÀMc*r,; ê¦ÓePÔ™llÓÉ«õâƒ?õ&زxº‹Çfo¥ÍžX1€ÐiéD—õ®í ›¾[·P|J ¦²µ³¥âµŠóô#:°¯‘Øù7¶Ò¸gØÝ4éM¨2ýrix<´/ÊíÌsðBÅÐõ®„ ÇHQÕé—°«ÅGOHéc·X&Ù8[á1¼ _œã0°t:5â ÀA¹[ þF.x°·OÏ(xCy« ›>A–ýowwú‡½5Y?ÍȽA&<Ó»ÅÍu]—xÐs1ˆF%ª Û½˜¢º-Ä ÿ-ÛožŠ6ˆ ‚Œáð9Û‚~Ë+Uø+Ÿ¶K£7Uõ_ÿPK8šŽš÷C '½ PK Y:C G Haxe Toolkit Installer Template/Haxe Toolkit Installer.pmdoc/01haxe.xmlUX ‚IRYÉCRõ •TQÚ0 þ+Uµ×6ìÆB$6®Ú¤=œÛÓ¤)S2BÒÅ)ûõsK(9 ¤í¥©ýÙŸ¿Øny½« l¬¡œ¦ƒ|0L“¦QëiZ<Ÿ†Å»Ç¬OŠìm1˜d“b4Êf“óñìýh\ÌŸRÁKk6ª\ÁxµQà„uU¾•Gè KkõNùî=å9ä,Šæp¨¬-8àìbò5`éTí;ƒ½²j‹>S½Ô:ñ§¦©±R&¸ƒßr0küÖ:õG¶ äÁ…³ûdoézÞ5
ö
© {‘Ê {vö” Ù'›åÉçs*8Ößá!³x¤[\Iû
KûŠ¿AÇ´Zu©}ÂÒ
¾Ñ²B:¬ÖöeqÚ¯¬VåevHjY@kYîd o „{*ãÁ©©õ,†§²¢/ÀYkv¾sß0o›ð¼–~{#$œsj`I¤§g
Ë~M}<À’Ü"vp‡·–Žæ 9Âp#O¯øž¦ˆ]ál…V7>VÂ.¨k}Fâ‚ò0x4!ü<Ô¨’ˆ«yÞµÿ¦‹ZÝñ]í^g¶Vî 9‹âEou ž§æ¶;¤4dZ¡ƒ®üÊ{M»ÔÃm$m` ¿/Þt@kõÞ 9 ÌMy@UÚ²{h-obóÅÏn=#]•³óßGüPK õ;ÿì † PK Y:C P Haxe Toolkit Installer Template/Haxe Toolkit Installer.pmdoc/02neko-contents.xmlUX ‚IRYÉCRõ •”QOƒ0…ÿJÓwÚÁâÆúÄLâ–˜Å}&DJ‹ôªÌ_oqÓ,&.í[ ÎwϹ··]õm Z!(4ÄôP²0¢ëUE”
Z DlÆf6#%ZÐ\AÑRR j0¯*JzË,âåÒžPPþh`0ü(ã÷ƒ~
ßæ#eÛ Ù)‹J ÿkÐ ZåÒ %¶TÕHøIÂnÒ,E=Àÿ!æó0Ž)?›íõþ6I]å*ä[y¡ú±Å³¹°g×Ú“:ëtéI¼wN ¯Nlž¾s•{ºF‹ð×én·IöiâÌv‘M&S¥”®&eï.÷¤æUúW^ÈÔŒ¶ðw^1:É –>+‚ö=W‹j{¯áØi6~–^zƒL¹6ýi7Ûµüô.øùÿ¶þPKŠ/ î PK Y:C G Haxe Toolkit Installer Template/Haxe Toolkit Installer.pmdoc/02neko.xmlUX ‚IRYÉCRõ •TMÚ0ý+QÔkâ@»HÆR€]µR+A÷T©ò†!¸1vj;,ô×w’˜à•@j/¶Þ¼ù|ž„ÖUi`ÙŠyO“|ö0[M §Ïùb3Zhµ%£b ʉ ô)Ó=?Awl´–•p©‚J'ã4K± %7=‚±B+Ö’%H·` #j×òÕÚºD(블‘;×0•VF
ün„¼q{mÄ Þ Ù;?}ˆÇs¦˜‘ïË‘w® ¨È‹Ñ¿ p–|ÁÆ#ßyôµC†²DÛNqM:TØèùkˆo]è°ÑŒî$/-^ZJý¾> Þ´Å7¡*‹ÝÏÖ¼¨x k§
ø9…r`—(= iF±,
PÒÂÎÖëfS¯P#Î/ÜíÓ¾À>×]wÚPd•%þ8 óå”q¿Òƒê\7k[ Y‹ÌX
«ÁdÑÃf¸ý¬àaߢR·ájÏŽ¸2§–0½~1=X(‰y_ƒ RÎ! ˜ì ßPcR2åØjë. Ì
0¸j˜}*5ÛŠý~ìkû®æ¬°Zv-s{ýí¶¯¶å*\ãÇ¡Iç\Ö¡ÊÄoÊ||ÓeL ÷`àSxþQ⧟ûÄ7á¿<ðóSñ
"þÀ×Ö“š9
—ȇ^û¾SŸQ€óN¤’çPK"›gyñ œ PK Y:C G __MACOSX/Haxe Toolkit Installer Template/._Haxe Toolkit Installer.pmdocUX ™IRYÉCRõ c`cg`b`ðMLVðVˆP€'±ƒøA È@€+ PK%í!Ÿ( R PK
>C / Haxe Toolkit Installer Template/haxe-3.0.0-osx/UX ‚IRgIRõ PK >C 8 Haxe Toolkit Installer Template/haxe-3.0.0-osx/.DS_StoreUX ‚IRjIRõ í˜=OÃ0E¯C†ˆ. ½2„‚øVU6„;”V‚‚ 5©`ÌOçÙ¾…H HL©Úw$ç$~þJ€™¬çg€P Ù„›
¦YË&¶ñ€ËÓµä¾aŸë¯Äsñ£”û”üç8ÁiL¥”$wüG¯Wìµ7>ìÇREQv“TŒ† †¢([H˜ íé&Ù0žÑy«Ž¥ íé&Ù°\FçtA[ÚÑžn’9i > {Þ ^Œ¥ íÿõÊŠ²7 $Ù°þ_ü~þWe‡1ùôf:Á÷ CXk¤»Mp5Gw¥Ÿ…Gø‰;ÚÓM²ne(¾ PK§N¼ PK
>C 8 __MACOSX/Haxe Toolkit Installer Template/haxe-3.0.0-osx/UX ™IR™IRõ PK >C C __MACOSX/Haxe Toolkit Installer Template/haxe-3.0.0-osx/._.DS_StoreUX ‚IRjIRõ c`cg`b`ðMLVðVˆP€'±ƒøA L… V PK¾CŠ * R PK
j>C : Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/UX ‚IR˜
IRõ PK
ú>C I Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/UX ‚IRÈ IRõ PK ú>C Q Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/.currentUX ‚IRÈ IRõ 3Ö3Ô3Ð-JÖ3 PK€Ãþ
PK
ú>C T Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/UX ‚IRÈ IRõ PK ú>C ` Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/haxelib.jsonUX ™IRÈ IRõ MAOÃ0 …ÏôWX9C
춂Iã†&ê&^H“)vÇ$Ä' cp´ßç÷ž?›3p"µ5â¼ë_wDgiN^A‘Dv˶-„Žihhe¼3¸:Ü êJpà<¿¨ÊÄDjSTKl’Û‰‹¡ =GþEï)ñ‘Xè+}y‘Œ^T%‘'d
Qjè;Ç<Ç“º_»ÁIìßÆÒ¾Ó 7Öæ›Îxd^¡Œ H<•¸_?=Â6¦ EÃzBïa›3X×tƒ$×ÏÓÏ=š÷k¹< †=© oȹÿ¦ùj¾PKȈuÒé f PK
ú>C Z Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/UX ‚IRÈ IRõ PK
ú>C b Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/UX ‚IRÈ IRõ PK ú>C o Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/ConvertXml.hxUX ‚IRÈ IRõ •UKOÛ@>Ç¿bk!a‹ÈÐk".¥íµ¤ÒÃÆžM–nÖÖ>€å¿wö?€C/‰væ›Ùù¾™Yw´þK×@LÛ
]mè ¾Zf|ÛµÊw®.u+—YV ª5¹hå(s¿Ùk6ëìJðšhC
þ1+kÃ[Iê *¸DÜâÖ(.×%Aüìô”Ü‚!¶#f¤F0äòö×&Q¶6Vž¨"x-9÷Q³\Ò-ä ’çs´Jä¤?b
õ`èZãñ÷Ÿpl@׊w®¸kÔÑrVUŸ£Y ªA¶f˜9!•5gî@6 kÎüºGë ÕòT¯©Òà™ÞÿüA¨lˆFòîìGž/[4Q¨ªsð Z¹ŒÞNµPD ®b\is±á¢)<ÂiT9mÐ ‘ÕLôê!Q )*éÖQØ)Èií¬U¤m„Ë)Ñî;¤Ÿ¹©7Á_¹Ÿ»]Îܳõ$¿ Ø‚4 o}v……—Ác¨ë(êM¡X×䪳zÂ}µOyé‹í•/FÃ^Nå&9“2J(Ø4|9Â
*a‡¬LV¤˜Ü:šÚQÆç?3ºiÕ}67bq~>äà0ïQM¢ôHÎHq@"Ô
QBóü€¼&Ü„á>|ç€5GZý2Í}]ó~¸$¾iöÙ£_A·
ð9‘þ!Áhgúà½êivר˜ñ…,¾îðr^ÏqÒ± sžçáùrRè•SžIø‹eAe½ªhÓù냗$¢}[n¬£ï öˆ¹%J*0'öW—‡rb~Já%IéçIñAjF…gèÖµ4m Õ§ ½YÙ¡É
†ŒJòÍ Kâuj’8ä„䄤)˜´Ç};*í…âlW¼Ÿ=„úNF–!óÉ1æ=b¸öGžÑ±úÖFÜñƒ<
Ø}pÆ–£{´ûlÿPK|Ñ øÅ é PK ú>C i Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Data.hxUX ‚IRÈ IRõ ½YësÛ6ÿ,ÿŽ§–jšvÒ¹g×¹‘%:f+KINšëôjˆ-&¡!)+jÆ÷·ß. |è»ùpÔ6€Åîo Ø]€§? ÀЋu=ÌrhvZoÎÎþqòæìõ¸a_8\‹e°< Rñ§ó(Ëp¢ f<åÓ5<¤,Éy`C˜r"ÆÒnC.€%kXð4Ã
bš³(‰’`ÄÊG¹DœÏS&Â|ÅRŽô°,~Ä%Â_Îy’K F1Ï ™Ï8Xc½ÃjÙÄ
EœÅ%@ËfVQ>Ë Ržåiä‰üx³ Gó(7ŠJÒ$ñ]f¨
¡µa.‚(¤ß\ê·XNã(›ÙDÄ}ºÌq2£IŸ'¸‹x¡B§"…ŒÇ11‰P©t‰Ñ–J£ 7×æ’¢W31'ZbT¨„æ
—i‚‚¹Ü4Ÿ”û‰û9Í÷PıX‘Ž¾H‚ˆTËε'¸Î¦â‘Kµ”ó‘#j…<²(=—²C ¦\›…GÒZ¬¢YJ0² ã!Bg,D*ånjì 7.Œ×“í‘ Þ†£Á{¯ëvÁjqlÙðÁ›Ü î&€£vò×Ðî„_½~×÷·áÈ a0"nÞí°ç¹8íõ;½»®×W¸µ?˜@Ï»õ&Èw2257Ï ¿[wÔ¹ÁaûÊëy“Òk×Þ¤Oœ¯#hð=šx»^{ûÑp0vD9÷½þõ¹·nâ `œ÷=`|ÓîõH±kß¡#
ÁðãÈ{w3›A¯ëâä•‹øÚW=WICí:½¶wkC·}Û~çÊ]d$•$J>ܸ4KRÛø¯3ñ}Ò§3èOF8´QÝѤØýÁ»6´GÞK GBÖÅMÉ·ö]ň,_w’ÐønìÖuÝv9Ži•žœ|z°`þgöÀ1*Eœ93L*q4½8ˆæ@cç¯háŒ8 xº=ï&yº®Oÿ‚‡ãâ`™QhñÔ%â}qp¯<à!Üe<õ’Pdp _,…„Í9œkú 5.ãx×<Ÿ³(Þœ\¤‚NW†óí4eëŸÕêÛ‹ƒ§Rð{<¹ï²1nÉØ%×sJuYe¾Â{¨ ¼@¯€gþæÜŠO³h†X%<ÝœÔÙk Þ2}Túm®èéÒ6U;¼ÕD9{ ‚ fʶÛPLÛû…zìRy{tðc¬:C–ÏöÐw¶£%?òXPÊÞRn¿Úzç‚'O|Jœšâë–Þö`xR†“ˆ¡Ër†6;hÈZäCFUÌðËñ%XúÐ9ŸðàX»(»íU ¿ÌãÝtÝA§BŠµy?éÈÅ4éaúHä²pŸþäœí&fñbÆ’å Iÿ{úŸßÛ'ÿf'üóOçäãÃSÜS!îy ·?Æ´x ¿[ï†=˶zê×Õ¸‹?‡’=þ)ßú£¾«…;zïvÿì·o5Ò‰±ˆñ&ºp™Èž2òfý¸A‹‚µ…Mxe4pæ,÷gM¢kA Wù,+°¼ä‘ÅQ –âZ.OuLtˆ°‘ò +ºdïd‹8Ê›–cµœO"Jš®…4Oû±-“ýèvp¶ ÎÎsœÉo}ÜÚÄÓ4Çä A ·ŽëXŽG”ÎoK‹…©òŠeœbp‡9²¼Õ¢B‘6!¤V(ÔœtC¥ 8x¶²ØÝ5CÇhaÓ‰h™
q¹îÈÞ%mžÙ•¹˜'˜NäqÒ#²Z5Qÿk÷:”ˆŽ-l¾°o~FÛK^Wø»Õ,Œ»Cß—j«N«C£*´Î2AVÍ°åäB±i¶ªqˆ•ñyð2cï€ÍòŒûŸqò
±IeTr']èF8
(o]Iß«bÝ¡¾ßV³Ñ˜¢Ÿ /’¨r³BU=½2“ ƒE°ò-!Õ
¹¹QÚNºù4
C[Z㙃&i:¦í4j$mhlir(ä™S°W˜p-c²÷TŸ(´ !s6ÎÊRV‘upTņãMæ”!÷ À-‡¡Ži¾å2A“´É
7hk I; yÀýá×
O÷¥Ž.Ô$ÃnZ4 ²i“®hµîS ®WìFõK¦Ì ?rÓT¤äiÊÒ5vžŠÅ|Èã îi×=ð0Jä-H©èHHªý˜ö%óBaO¬xÚAëª8”0zl>
˜a/ðe6ë%Ê6|ZðN^× lRëð«‘ódÑ/¼ ¶ÀÆ EbŒ ‘Ñ
Oà]LµŽG
-¦’÷UËþ§²gk‹˜ë^hVäò"Ï«|N2k]‡üÛ–ÊhëÔˆ‹bù 3<Ýœø¹–Pݪíß5*¬áPY‡Ê2KÀ zsÎîq|ï˜â°”•ø|‘¯µŸè¥’AÆçt“ñÅ oF,Éõb–EdVþØ Šÿ;¨—Ÿ•Ú ÃŽ2æž Ù”KÀXYù3‰q»ò aÏTÙÙ‚ûZIun[€k¤3±Dc"âúÉzîFE7ÐSõÞåõ™+ 5‰—@KÏ‹ÞÒ±G3\Z:6×É'ÝùS7 øË:o:OäÙ’ýòé©|qI¼†<Â.ãÞ´j÷òŠj×X`ÃjÆ1pè¡3KŽÈ]8”Q$?†L×JŒM_µ!AKÄ1EP˜Š9Æuø±lÎeS
¨þ΂½K#aS‘}”ßb6bPóèQŸ™ ¥fXÉ¢6EvJ<§ =ËÔGy±×}L¡‹”?ò$'vH?W¨c*ÇQ²¤€FT!¬8z >Qp’ hK$¿a<¤l
õ¤… àÒ2s–Ó
f œTœQ»iÌ’ÏÚ£ú!M§tnÓýÕ%uû-øGàde
W¯6Ø{YÒmÅó ^øJ^ÆTÛ^$6C!Kîyí]x³îÊ+SnŠ®$Õs;,šU89fuðEZÔqGa§¢N¿>>¯ÚþìDX%(‘ú„´Öì)°$p ¬ÿM°ÔÅ7 J¡¯ÚU sÕÑýª¯•›•¦Šõ™Â´P@õµ@±ÔšAU5K5
RLš¤x¼ÅV¹x¶=/0>U^¾e(óÄ}©¯¨Ë4V ;BMÄ6Ê—p³•i´ 丟E…¨ÎªnÜM£np1ýoÕx»Œv朩Wàëx¥ì^+LUàæåßpÓcÍé‡ ê“²kÙb^\àñ]ò9«¤à_öFB1³ m¥÷4XËG#ÑåÓ¿þ˦Ùò‹‡þËV•S~ð _r\~$ÐUg+ß.6f$Uù¡¤ønMżòA¤ø[®èOôKc©|¡¡gkŸ7è”Pä«g°§ÿPK?ÖA% { PK ú>C w Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/dbconfig.json.exampleUX ‚IRÈ IRõ «VàåâT*-N-RR°RPJI
1uÀ¢‰ÅÅPÑ "š‘_\ÍÉONÌó )‰%‰I‰Å©`ɌĊԜÌ$%^®Z PKü‰{F c PK ú>C m Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/haxelib.cssUX ‚IRÈ IRõ VQsÛ(~®“¼Üu"Ù±¸µŸ2ws£ƒ’h0€j»ûï· !¥tÒ‹'±€ÝåÛo¿]eµþˆŒÕ]i;MÑÇõju–ä†~®>´X×L #ÚœV &„‰zXYzµæ¬GTRa©†ÍJ
›U¸eüfVÓsW6Ô¢Ö<<,Lf¨fU°4ì»çM^( ›g\~«µìÝÇüê4ÿ㡱V ×ë_i.u½fmíësý¥ÅLä5« þDš*Šmv=þ]åœÖ¸¼eBZVR—ÍYjBµ»P]‘‘œôøúúSsP8y‡%ÄR¸¦‘þ áÎÊø4a¨ða.ŒØV‡¢óËJÉ¥ŽYž~….kå¬?Î4&¬3(B[å-Ã+ÇœVŽÑŠKlã2 z.Fï
åûÍ /›€S¬{ÿpDgiäeu㽤ðÂÇïÌ0K‰·üµ+›QQ„–Rcˤà ¤ >>6ò;Õ#ȉÐI5gƒióqwmÇsp×·i×fö¦àzh9«øn2®ÂîXŸ‹$ð¶ü’¼X¢Ø£<-^ èwFïŸý½}@êáÌa/ÉÀï
ãÆ·Ë´=6Ÿ‹ÏŸ^OoïUrlÌd
ý¹Û¼Ëô0ûÇ„`Ó@¯>¾¼¼Ìøßn–æÒöþ%RôŸ4ßVIm[I`^û
`’
bÂÎ9õÍ vœ
Âêg]/˜ K‡Ã!^B’ö šb˜w“Ë&’|Üï÷I;ïµí»§Lhëÿ PK¼šu˜ Ð
PK ú>C i Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Main.hxUX ‚IRÈ IRõ ½}ûWÛH–ðÏðWTôeÇrÛؤ{fήÓt– é°› H÷ä ÙnaË Ä–<’ a2Ù¿}ï³ ² Ì|>}‚¤ªºUuëÖ}WyøݦùÎì‹»2»º®M¼×ý~{ûO[ßo?ûÞ¼N¾¤æU±Ì'I9ÔÄÊ'i9Ϫ
>˜¬2×i™^Þ™«2ÉëtÒ7Ó2MM15ã뤼Jû¦.L’ß™EZVÐ ¸¬“,Ïò+“ ¨1ô‹•ëk€TÓú6)S¨?1IUã,fRŒ—ó4¯i fšÍÒÊÄõuj¢3iuû
ºš¤ÉÌd¹Áb-5·Y}],kS¦U]fcÓ‡JãÙr‚#ÑâY6Ïj(A ”TwYÁTp´}3/&Ùÿ¦4¿Åòr–U×}3Éú岆~ §9´BX0¡aQš*ÍH I»1öiÒÐÑ‘[ º¨ëÛëbŽu kº,sè8¥f“ÐGý~JÇ5~AèÓb6+nqŽã"Ÿd8µj$«xåÉeq“Ò´xñó¢†QóPpEn¥¥¨ºN`—© :Ï[‰7³‡QÕ@,Æ¢(©ßæŒ:Ž×æìøÕù¯»§æðÌœœ ÿr¸°o¢Ý3xúæ×Ãó×ÇïÎ
Ô8Ý=:oŽ_™Ý£÷æ?öûæà/'§ggæø¡ ¾=ysx ŸöÞ¼Û?<úÙ¼„¦GÇçæÍáÛÃs€{~L}
´Ãƒ3„÷öàtï5¼î¾<|sxþžVíÕáùB~u|jvÍÉîéùáÞ»7»§æäÝéÉñÙ b ½:…ŽÞ cøf~söz÷Íì
Áí¾ƒiœâ@ÍÞñÉûÓß_Ÿ›×ÇoöàãËßîË7ÜÌnïÍîáÛ¾Ùß}»ûóµ:@4I¬ÉÃ4¿¾>À¯Øë.ü¿w~x|„óÙ;>:?…×>L÷ôܶþõðì ovOÏ`À4ÇÓcè± Ž 4=:`@ˆùp
¾¿;;F´°û ža{¿>.òps‘Œ?'W)Pe1«×ÀTfÙåóÍÍlŽÄaðÃ`\Þ-êbðvò§çÁ÷ïÂ׬œ$õuøñoÙbpš&“´´ßƒ®ûIآꮼ&rvWÕé<ø ÐýMªÁñ醻¬p'Á&ϯÎ>|KóåÜìæÕmZš¯›ïSø¸qTÀ?»³ÛäÞ¾mnŽgÀÍÌYV§'eñåΤ_ê4ŸTÜC™ÎakåW*û1 8¶Ù]d?l ê]'«B00ôãe½ 6öussã&)MaF¢ç\0^–Pt˜ëû<ù¼ÃÖ…éÌ«Y‘À·Í
bqc`89ñN“§·qÑÅùn ›fÇà”7òŽÙÆG²cÎ3à“x›/â.À46, Ë»:âœAaãގɱu6iX;ð¾ÖÒ…o°`ƒ ¿Ž¡j/âÖe„`7ÒY•¶TF=€•ã¨wVOX€%ß=ÛÞ lw‡PØíEÿÒ0ßÜl3–e6IÝ´oKX—Ði<æÿŽ‚'ôìñ ª¸ê/ú3†‡ÈGzpµÜ/é¹Lk`ÿ¦|¨£ñ¬¨Ò˜ÁWKàçùòœÆï½`ç5,VsÍÌ„Ö©)pý ƒX4CjÒ…¿Ï¶¿ÿ#VŠkzýJ¹Q† Ð*ü Öq«í·9âÄË|1Kë(3êy€â>êaG½¨Âu&€½è?_«îEþðº.Êt)ž3šˆîÌœ[ìºÃ|eß æþ¶Ë¼mG%²«E첺¨õ½}‡™¬O•¼–ÁÀ²çú†e·Ñ;VÞÁ&M¸^IDëÈnŒ® N
dªLÍJpãÇ®âËå´CìÏÒÜõó9è'¬äõùÙïós“mH%“óúMˆd"TR’%¸+!½!@.ê®é™è_€ ˜ncÝß‚ºJk[¡j868‰_@b£xNç¿ÀV)¦,â΃gƒír<ø¡ƒ¼F»'‡÷¶ƒÁ4›œ œ í¾=€úƒ(,<;8xP†Ó¾.*¤&¬F²cP”WQŸðA¬ü_·ñe’!ã¨`YÎð9Ë'é—ANŸ’Eƒ"moä
w0O>°ÛQÏÿ˜åE ¾=ºm¿)Xà®ÎnY&w?òLRTÌç n¢‘yzó_MžÌqksµ>*ýÞÛž)²‰Ùú‰þöa‡à¼^‚´4ßhLó Í‹ÛyŸñ›Êßç>-áNcÒ¡ÑÂÒ Áà#î”J:Ð ¬JƒåÝ‘L&{\aaf³
zêýfs•Ý¤9X—eR‚Ý ú1~çwT˜§%(ø‰¹þ2Ÿ‘uÀ£àø§oè@HÀ=-0¨5M@®€X.ÀB›¤P.O HžÖÂj† ÃÀ0zÔf©Îrµ)Ø>ÓFó3øä@ˆÊc²«®@=éó4ä‡&‚‡7LÃk1Q¥ˆKø@À¿d” å–`ai †,’ÌzHI9¾&`ø KãVvžÔãk2vÍmQNV'•åÓ‚¨fZhk|.ç‰ØLysz-‹R¥%âþ<ƒª¶`ö
}$ìò#4FÂoo
† X«žð€¥$rK2r#f@mÔ˯ÉrኒÈç6qA0êëµëF.,`
û(Bc^þ2ÇÍ(/
q [
eýö îÕ±AËivÅðà`‘4a÷À#Ç%…øÚãRÐ3Y÷ïÜr‰´ ÿâ¢,Ùµ*Î8›fv·Þ‘ –ÀEaÑÖC›ãÑC=6BU‹jÍÖï€Izeð¯·jð–Ίzl HœtLâ ’ò:¨WDRWDO@w>úÈNªõ»a ‘yTËëu]/ø3·B3#Ïj b™À'_4¸RVŸEº€4¾P£á0Åð€0è#ïÉ^øæׄ¨"† ô € öÛxr¹
„øs™È'+äâиÄÉïyžÒÔ°¡¼ÅÞ0ºØÕŠ‘FD“|î› PŠn'¢m¡™†²r êÛÐßOª½&êVøÀß{½¡N†@AE¤«f_ÐËo õ—Ë) à
ôyÙ¯If_¥õÞuRÆLRÜzcœT)(z}ó쇑¹µóós÷}<2 êv°ÛoH·×Èâº\2mnˆ)ƒÔy¡Â-ê}ÿæ4V OUO²<î’®û&ËÓUë7©>Çæ¯Ë´¢7 2u ìZQà°¥uc î†ù0ùh^æ6ñš®Í;Ê£‘‘‘’«B¿ß¹ïìÈЂĨ[CpåM
õVÚ9^Ôñÿ½ÜÓ·õ…B§¤;¥¢†¸ãcRU9\óØ*œÜŠÕMjˆºæTLü÷ÛÊÊ-+`Ž2'¡
r•¿fü6É¡Bip«ªÒ[Li ³ï··ÿŒîõ šîu^IgÞa bK¢ü Ãÿh>䑪>†
ö¬JÍßãÆ`×ùbuØ®GÌèÛ€ðÓïêþL¿dµsdx¶r1+س 'éåò
Mûî9ëÑž ¨… É4€òÕ…f ½>nÛ*'!9oÑ¢ÕÖá`‡ o¡ÿzžËZêÝË Ïß OTæ 0N¥-™ó ÀÛç`Ý8ÿ=ü¯˜$ÅÅðbØ}ø/xúØëÆ£Û[ÿ/.†/âÁwݧCnˆ³RHkŒ±ƒ® ìû²¸5Ña~“ÌÀ
òd!+z¦õ°A/êD Ë—K;F€¦“øû®ëË}ý¡kžHßðeûj`/W)w±ßl@®þ(¥ô‹¦¦ßí m·&vU Ø6øƒyâ• ‡åWÐibxÝ®'>Ѽ‡oÎà¸øÓd9«y•xU¶¶ž7¨HÙ™¡óIë""v¨ÌGŠìúûöµ£M…M‚J¢ÖŠŸ´RŠ> ôl±¼mŒ*ß6¾™1‘‚A>°`Áöïú`¨›øý¿ãBÿV¦U1#ÉU²ì é êyT»þ)Ø@CÀ‚" €69™¥Höi^-KP”¯Êî
ØØP˜–8ú±Ý0ŽRþåA8œb àªyUo´ÕòÖæ f\c[—©ØLž²æA]ð¸&êô/QIåˆJn2¨EGó="CŠ lW bÌ µëŽò[R}ÍØä§j꾦,Œ~°æ=Ìa ³fX§{ÒLXG· зŽ"d»ªø+ýFõ9´-0j· J…Û
Ì9 LŒb®Úµã†æG!àŸ(Š˜UÉ%ZEÂ* 74f¹Â76òôs1 ü s%®§Ú„GŠ¬¤bµ)U¦±
ŸÁ³à·»V¦ú.ÿœÃâëÖCÑ5ŸP;·CQh
‡f þ3{Çoßî íŸÑ[ó¿ÍMã¤ÛñžpC« «ÀÑ{¦ W‚quýjûi5ÖjxöË~M/±o-¾åW¿ÆŽ“k
›û5Žoó´Ôò_üR1´ x¸8qüJ§)1Ê74°¶Tµ
)ì±í†–ç…u • fbîÒºëiY7¸Ê>¼ ÛÍ ½!°Æøèi]7$c°•«-3-½Å^²XÑå~¥ëךÚ.› z8Y·Ô>LAâ5Ëß&ÙLËÓ9¼„K(dÛD/°8LGx½–ì}œ.§
dE{]¬`L}V‚5ŒÈi!ñr’sKªåµ[@ÀêÖó€rìº:ܺ à«[E¦«ðJ¾¸:hòºò4€‘Åôª•¾wµöÐ UνJj<£&Ç• a¢:*T˜GÊRŸT3Ò£¤ÿ·“?Ú5.&iŒ_ºêZ”þÄûXÖ§I÷J+
‹›¸c§ GË$¦½{ŽA²)’
ŒÒ£]Ï¡"lckü-[@ú“û¿³EŒN
½QŠ¿ÅëoŠ›aN µ<$¶ *© ôÖñç= aÆU ¶î±‘4(ÑÕ@<`À „ðwvž©ÄÆFkV„ÅÔÈŠ: gsƒI!¢^9êu2ˆ“i «HmõiDg¶ˆTé9Ø ,Z8<Ì“7Éür’€ÂTÅM(ìaî;D%J¤*?Ë™ê(½}G ˆ[ðT¨`büOº$͚Ƀӌ@#SÛ¡)x_¬>ŠNé0»)ðw£§±ôvµBÑ
°ãoe!ÍÈ8”{Uƒ=Ѷ=¸E !€(GëQ}i±Á³2±µél§8~F,Ü?> 5qÜhöu e]…©ö¥¨ ÚÕunÆô‚z-«ï”+O„+ixõ<Ó^7˜§sL´¿®µò'*+I¯D}ìq±Ü‰Q ä{B ÃE.Á¾±˜ëÅ*Ì
Ñ:|ÛõN²Ã¹ ªVÔ³)n*Y8Ú Ö‘gÞ0>Š3ÉxÔÊÉ &UV›²¹*Å$ÚŽ 6ƒìªø[`#Š¯L6%Á |‡Åêh ªxnO4ÚÑ‹‰fO§¤|Â%% b^ å°ð”pê\;Nêôsc‘f]ìí¨h¸=v/‹²«Géô¯Ë£ "VL6aëô6Ã8&PdM5¨l¢$ åŒ NbKú ¨ #²J)ùQ,ID8Š ¨kñGã§ØÆBÛzdßуByHÎgO»àzPäeY OVA£ZaxÖésóMëí³<$–Áßptçe’WÓ´ÞHaã~6éã¸\ªÊ½±ÿŠ€
_<õè ЫGÅðŸ(x× 9ÉNrÆ¢x±ÁœJëäsjªbÎ&e t|GÂ-üŸdµëéĵÅÙø=ÎU÷l{›¼u0 Ih¥h AÚh&ÎëÑƼºRâ0Ä€Ð{;Ì@›ëŒ<1ÐÐåaþä°å‘ 6¢G±2›QàÙ†â¥Ä[óÝ€`ÀÖl¸MÕAì Ø+æ&à–"( _•Å|w6{
b?®a¹±Ž WrÀü‰LHò×5Š³j_Àu„é¼d¤€ÞØ¡7`jCË…(…³ËGÊ—®ç$¨‘¸I™Á{Ó£¹©½»âMàa¡"¹:*üšp†—®Çš@Í°ÿIq(#@Ç7Ô&ÁìtË•q¨h@ÌE8ZR¡ë,g!£ å·»Šä‚ç˜VHž/¦ú‡ìAþÕJa/V£Å® x¦ØÙ(}ú^CÉÚ’9Çj[ö¥¸ïIùUó<Ø=^ XutÂŽÔó¾yẑþÕ36 èÐm+BóÝgV€ë8A~_‹lzgà':ùhä:w˜³rÕÿHÊd8*k6Ušû\¡ n*3«ºLèæn*2‚
`2`é^{ºŠ<6Pû\EBt&ž›Pû³;c$²J$8‘~w4ÓZ;`æ50dxX¯Z–§¨ú`“Aµ˜3Ž8—ÓV¸¬Î•ìD ¿M?jÆØW ¶PJ?$œo?Y'¾‰‰{Ro–A"¸Ù ªÎcÕW¡Þ€²`eÛoa>^×Ûõ”Û˜ÞQK ‰üI¶;ÛIÐ
¡ŠÎfyå îÈ: êêÃöG¿ò‹G‚&¦š.‚ò¬+mŸi[&BÖE©ƒyøxS†Ã"Í‹cçTW´å°z•ÖX°KBl$Ãî+EŒ¼A~ó=¹j‰¼Mò»p$ëdi ¥BJzEvš2
5i'†43àt½.jMhôÙNâiWãÚÓU©"^ÛÞ¼x•¥¢"RlM_ M¹¼¥ Ó¬Vt YÍ|JêBGÝæÍ ç϶gý%5 ªÐÑ«
,ÁŠZñ>ë1*ͳʅ„,¾µ¯-mÏÑ! ã ?Þ»·]íq/; (VÎnbñHŒaD5‘ 궮›êM{dWáp•©åËù¥ºF“WE1áºçÇûÇ#ŠÒÜ¢å1›%‹*euQ¸dÆÝ“CƒùO/Œ9¬;J(2eêè 8i –·Y•œ û¦H&ê“PƒˆrÅþº®¤WúLèÒñ VÑ=snÛÙ`½t¶e]ßô<¡¥NH}äP”F³º›ÀkMÄ„ <]?öU¥n
£çp#²z9hCeø.û˜zç6/᫆g,§\æáZ‘ŸTKÃRÏa"TJ-;±~êÜ×ûu ΋OÄAÇ´Œ>#È\
-í±ŸËÃV£ÀËÌÊx|~·Ž·IÝÁ¤ß¿ÿ}åëÅ…|“w g¬I ³ ã¹¹30`e+ÊZûp1¼¸ø8¼°y`ÇÐD‘û$¡ éÝ,¼+‰xeš¼Íâ@ÕÈV‰mïqà'¼ï‚êÖËÖÖz
1ösV{ xÏÞíÄr”@¥dåò‡5` ‡( èÉ’Òk¬]NüuwGàÀ:&Ùtj¶¶PYÚÂu!P˽uÇ žn4R!—;Püö4%ßçu’_¥äX‰EÙ‹A0ƒùIn8à¬Be=‘/¬ƒOr¿—› ø¬pßÁ`±Ç-Ø îl,5?*´‘!—¡îèìg Þ,Öf™×Åçh’ˆU L»2$œš¯ø‡”ï-’·ÈL +G \~A#¹|ÎúÕØ{(f\|® Ìbî±!ü t3üÜH ¥OOœ°rŸ&ÞÉõUL
D
xÍU y¯²üa/á26VÛËÛTsÖ¹Hép×·Ÿð¹v<+×—÷™ƒ}c‘ÄðÂ|y'ðO’TóÏÈÓ¶ ÇËO Ö‹Püé=oàšŒèŽdDw¬æö¤9¡®Çϱ)Þ¢J7 «.Œc×xwO£S¼^L:¶%@ì/—Ùl{á¿… ÈÓÕt@»Ó7 :[x–ž:ÈL9>aâ þ[à·ñ,ƒ%£’9Ø T9¸Áõ|ÝÚÊ‹‚®aí| ܳBï&^¹WLÄùB÷¨³¶Î
Ä
Þï’– MÞÅtófHæ›`3@fsÈ>fmÎ; 9»SR8jZšù&™"nY$`ÓîØ&æeoå©»Rã‘nØG,oHœ0@èÞã—U4Òj£‰ ,û- ¬£uLÁ:!ªñ}+ªù6
Óv¸]ɦ£¯+c”è{#;ö÷u`7v–9 Í/ÑrJDÁÈÃï4ýü»& Úu{„÷Y+HÓÍ ¯ž÷'pZt˜N(§Q·ˆ ‰í"ßÚ¢«Ë‚qš^"EØlF_ÀtNB§ñ;ñŧwRòžíÌ»öC'ײ}?Ú„Êöm(àÝ¥–;æÃG•õ”@_Q¿^ÜG0Oï\ä°ù,L¼§„ï R~e0ø9ÐÁ;[ ¥&n+& <¹–Ö]ƒÍ½œÕ¶†ñÂDOáCdW‚~, ~ëK¶ˆÕºÖ–ô©C{$ÿŽ¾tþדáe–«ë‹œV·Ó£‘uÔ1n¯cÚ(†.c}úï £WN¬Š´#IÒbG5z\õx'iYÿ—\r‚þDòì³sÖ]_
ÌEnLC)¾/2PíÜå*!x4K¼xyŠë2 ÆŠ— ÓÆ´ÛœI êX¡Óf>rhí4 sÄôëãL??
ëùÂسº•UïÖôñ.*r#plÄ©8.œiK +ÁÁ•plã?º 8dåÎ’ßwÀå^”$S±•ä'R~²1‚•ó&í±l/£»îD)€íEìO¬½dJ6 V5> ^½à 0rÔÂhäW:xVšåAÆßj:¨N°e7nk&±î@l[²¨ÍŽä+ÃÄ؇—£\^Ѹº‚T2ÝZ.Õ5“ŽI‹Ê¥Âñþ™Ü+ê6 roo·Yon·zõjQÔŒ<9B‡ušWÏËš’ðc™pï ›Í³‡vÖɇíýäó}ìÐjf÷êH¥4H_ƒäàv‘Ë1løÿ\òbO³|%Ùj^ É•ó2‚z]O¢psÝvs×*S2bíj]ò‚M·Èm}äùd6‹ÚÔdÙ칯b³[î®b¹Ò{Óíá< Yõç? Ƚzxø"Æ; ñ"6hòV€çí®¶¢Ñت« a¶TrÅ-,‰«6¯ m¿ó¤å–“Å/¡!À
¥±Ð}?¼Òä•'¿ø`¬÷@q ¿–cÜ ÍjŸÏØf
_m¾ª¦1ˆ.½j\f æç. \Ñó<ÜP7>¾øÇ"²*ÝÀIÖg(ÒØÍ1 )ŸÐW˜Vãd‘î–W1¹F²¶KJò÷Ù0Þ*¿Bý®=Ì©q2†N‰ØTaÌòDî±õ,üyìOž;Q§—ôàßf/tßÛãîK^½Ï ¼p®‘‘.¿•sÓûxÈG4
~¤Ñw ‹÷I.íÒ¨:´ç†nu¡Ã½è¹7Ó¯T>ÂúxçÆHê£ØzqØ éú¾”JQjþH
þ Æãx”üBŠ¢–~¨¿yGù¨†ØüþÄÎün…Õ ÛMÆfõÀ¶âq„¶¢Ÿ.¦×¶òÓö§ÛZå:-dË/¹“Æ
‘»';YÖסÞÇÕèxͬ¸Êò(¨{—ˆ»f„0‘š«ðJÍÈ_ðò4—ü˜)þ¡Œù
SüCïؼ¯ôD¬p¤F ¸
}¾}ä†ù
áPŽ^´289=þË{–Bøë îªê”¯®¥ïö~dØÔL®@}WÎì-°···ƒ«¢¸±[-Z—K¹Ù\hï‡;¦t&ªuWÔ… õù®×³´Ì’Yö7¼pd5•wÞsŸ|Àm¢9Ò
þc–æá]d¢x¤Q¼Ë«p -Ç ú_›xº²¿ÝO;ú¿`ÜšïŒ%r'j©P§g&á¯@ZQŽñ‚öZô»¢§›¸EF
|2¤½¥íÀæüÝëêwæâ˜/÷Àýj ç÷#¡´-n-7 {«V©:ZPmÏbl È‹-” ®ìµX Öwt}…UXí]!FÅ`ßäk–gP—Îú=ÕšV·”_j¹ÿ?÷Ì £§_T©%ÙÅýR |êEÞo7b®¦Ð_ I¿—gÜì¹üôÿ PKDhŸê¾) … PK ú>C j Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Paths.hxUX ‚IRÈ IRõ uQKÃ0…Ÿ;è¸Ì‡)ÃôÝჶ¦µløT’ön‹Ii²Mÿ»éV×{îù‡Ô¬Ø°5‚ÕZR±O”‚Oü?($3æÌV¾ýg,³¢€ k gY²ˆó”Ò îÁ]½+±‚ÏY-Zɸ7š (
å?A•nAF#z¶Bƒ`*½•%p¡¤PºYy«•üj—}Å,î°95ª·\vÅÂeäê(Üh²DNÖhÃ}y}ãóÊ“‹pô˜‡ôeš<¹ˆ6h Ã’ZÄš¼†½Ø4™Å'¨ûRòqÊžçy”¤'È~Ô=ùÎ:ûç•A;σ#fq"}M2š¾ ýüPK–š÷Ú ö PK ú>C l Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Rebuild.hxUX ‚IRÈ IRõ }RÑŠS1}n¡ÿ0.…Ü‹5úÜZ¥he_ÔÅ*+,‹¤IÚ†ÍM.ÉÜm‹ôßÍ䦻ć<äœ3““9Ó
ù ¶Ð{ùN ´5ëÙh8š¦õ! #ÿd¬^ #êfvÏo‚—:Æ\!ˆ¾éug¬‚ß£á ¢@#aÓ9‰Æ;«d£¦+ Æm'ð¾‰Ûr90–¶qºA ßöÄ»:·˜
TDÂ|®³¶†þw÷3â E€6]ÞCqEoM²¬ž[´\ ~ðJW5¼˜Ã›ˆà.ø=°e>À˜|1x -¨tc>N¡¸º
>MèëŠÃòÐj‰ZA)€u‡ 4öàØG–z:O„mîÒ`èýÆ¥{¬®®?—7‹ï×WõÓì6)d
a|.y]¶»¾'
ž¢b¡OšÂ+Ò„Þå°WN?øt¥®(X¯`EüKZ£ ²'šæFüÅ.òÏ=JšûúÒ½‘ÅTµö ÏVÈGŠƒRø¼Ç\i›†F@E‚ÿñ¬k•@Íw‡Æ²^H£lÓ M.~db'iç6]QRPð•ž~<:ÑY2ÿ»|…*íX^(]Ÿ O PK¯, í — PK ú>C i Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Repo.hxUX ‚IRÈ IRõ ½ksÛ¸ñs2“ÿ ón.T¬2¹ët¦uÎQ,ùÌ©,i$9~ÉÀ$$!¡H– eûrúïÝ] |èaßµf ›\,öýøúÕ‹çì»Èò‡B.WšùŸÞ¼ùËŸ~zóãOìŠß v™•i̵ÌRD%ô‰(ÖR) 1©ØJâö- žjwÙ¢‚e x±]¦3ÆÓ–‹BÁ†ìVs™ÊtÉ8ÑŠ€5bëRÙBßñBÀ†˜q¥²Hr Éâ,*×"Õ$[ÈD(æë•`ÞÌîð:]"ÌbÁ&S†ën™ÝI½ÊJÍ
¡t!#¤Ó¤()c”Å-'r-u¥,‘ »($\*Ðåí²uËþ¤b^Þ&Rº,–Hþ¶Ô TŒD
»ˆèô:+˜I‚T$è@z×RvIoà”£µ5ñ¾[ekÄ%J•V`²EY¤ÀZо8ç/"ÒAò‹,I²;T3ÊÒX¢vê¬ræ 0øm¶¤š‰‚4Ó ¹‘ý’×·KjÅA[amì¥1ohW $JC\HpIžÄzWë åjÀfãËù‡ÞtÀ›LÇïÃþ Ï¼Þ Þ½.ûίÆ7sÓÞhþ‰/Yoô‰ý# õ»lðq2 Ìfl<%ráõd Ž.†7ýpô {{Gã9†×á ÏÇÄÔ’ 3$x=˜^\Ákï]8 矌÷.Ãùi_Ž§¬Ç&½é<¼¸ö¦lr3Œg£¤Gáèr
œ×ƒÑ< Î cƒ÷ðÂfW½áÙ½Þ
h2EYÙÅxòiþr5gWãa Àw°÷n80ì@Á‹a/¼î²~ïº÷Ë€v’ÑQ¤ìÃÕ ÁÈ·?óp|¢óPVU%)n÷Óx·ÿ4Z;e (X%Ø>õº?bÕ–ÒŽÔïS/ÐëÜk
°xc ÛtñÀpþ…ƒŽÀ0òØG’]]”-/†Fî?€µAÛ©_D
þ~çʸ*(¿ÊÜÒ§Á^ƒ)ï!J訰ï‡oD4ˆ’L ð§9Œ áÔÖGæ>4¶5©ÑD$o{šA ªÅÈ‘ZbÍÞþWÁÕýæ"ëÄDÖñ:O4³‚°0¼†È](1I T©¦ÚÓ±ç¦ÿ\üƒSC•ýé×ú¿ÙXW>UZÑÛ¶iq¨ÎÙ¯och4]pÅ0Ƨ@ÁaÒŸŠEbNkUÑ$ô{J¨!ìJPK=$óú53ǸªJÉ‘ˆE| ÚZsæ¶ZÞÎV¹kƒ-žn1¼6|§"·îS·fßݲOݲ}wËv³æ@«š¶Pb[ ØqŠ˜h²ÚÔÌnzfzAM ÕÄËò
Öfµ‚é2ýÝb©-K˜©+f4#c!àË
²ÏM â¶}‰íoÎð
ÐÜ>VÁb³æôÅ*÷¥‚Ý8¥ðÄÚ¼n´†ð^v,®uwd°°X…n!ú¾6t¡¹Ðàµjç¬dxmy ¿škF#{³Ld6Ñœ\ ÓŽpv#xüL|Édê{g^#¡ÊœNŒ¶™Q¸:Íê°§
ØJ
(Žuœì¤YuIp²“´Šnpc. 4_a™T©„E§§ó•:´IfÎè¼VͧÉCe;“tOív]CP8ïÿ“ùÆÚÍzý˜%ªP< ¿˜Î1LÃ5Á£¥ã‰Ú±_<V½òaëǶÒæiÇÙbƒ"šwºèƒº ¬JGËÒºt°0íU¦¦"[7PAv$Yö• ¨F!Rín.éGàúôѸã9rsôøH¿©¦y@îB¦R¾f¹9P•Pòvf·>)UCI5e¶ ×ÃælÕÏ"œ¬êÙÈ¢œìtXœýÂ5\só©µ >®“ ®uÀå–}X3So¨Ûž?0÷Í~§‹¬êm4e¸WäVdÙÁ› ëˆ{Jš ±ªHSw’†ÓûFDEx@ŸOÌe= 뻟»Ÿ;gv¹ÚCΩ·™}Þ"ájåuÍß¿Â ßð;Â__ø†»¥¿ÁšÁ¸†0âå9üÎWø›®ã½3Œ³ô¥vßÀœ ñËtý åˆÅ‚—‰>3†0—2÷U>ظ®Ñ ü0y2S“ü¶6´jºu&
Óï¯
—*,!ƒ´\‡i,îÛ}“Ö.84ü]¸r„|’¿f(>UãvÑÆ·9X08Yœ5Îfè.v>¡B½I%KåŸÓw[¹LÑŒR‡¦›6x ©gàÎŽ ýhÀN Èà7¥
bŽ ,ì]X·¸FðÀ´NdD¼î芾À 3ó)&ÈÖȶE¦ï xŠl)L[W1vóÖƒ¶ÅÎÑ‚o[ÕóNQº°ð6v»ÇÙijÅy§Mpê18Ê~We|
}ÈMSnÖc Ç„;exccÓ2±¼7{•µøK†Æ5V6¯nI¦%|ut(èª%zXˆÖõ¢´—Gåz`õÙý÷Ùx¾ºK“ŒÇˆ÷ÆÁ8Í#Œ"€3^ëR¾ÚvØÅ›f D@ã €í/;CËž?!
Ž|¬À41î% èt è k_Óä™Òaª4O’ý¯C]V±¨®Ož¸¦ûŸ} ù[çÄ*ü*“íæl+[]¤îÏ$!‘ÜýJ÷[fÁFî¹ãfC¹^7áÛX'@µnc¸^7€zÝrÂvq(š÷Ð ŠXµa7ö}åHŠó¶æ§§Ò
Â|¡ ¥Ûƒ §×\V_§Ñ¢((á«1È|,‡”nƨGú²mêÑ‘Ë-Bs4¿Ñª°·YÛõ(<-óÆ•“ÙsÒ²ÕþÕ"¢VoûoPKð§Ù…š Ó$ PK ú>C k Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/SemVer.hxUX ‚IRÈ IRõ TÛŽÓ0}N¥þìTmµM¹!Jµ,H UÝÕvá…‹ä¦nkHíÊvR»|;c;·v+ /ŽgÎ Ÿ9gGÒïdMA ‘©hC~ÐŒ-’n§ÛÉãk˜ë¥ÝQžoáZÒ‚Ñ=üêv¼‹éõ» Ly¯ßÞÚõæ2ñº{îvÒŒ(sºýH¥…ïòEÆR(ˆ„-ù&düžëä(Îx÷;¢Ó͉‚“Ïò,{Yj{u3Ë·†,mÈ*ç©f‚§ûÀ
8 wê &%Có†\¡íÉÓ¦"[c×VÒ„
‹ ›µ [V Ûµ. W‚ ¤ðÔ&‹@³½½h1×?^ÆîÅ©5vHª‘ÅïY±QÏŠ‹zVŒod+*1gcàèYÙ¬gjûX<ô¡_ ‰ÖTÏÈ–a¤ÅT쩼$
w–«Mfä×|6YóE-¾²1Û™ä’ÍU³J]…T{ù=ú|z4|ñ¥ ~Ž ¾Ã€d»
¹[PMîdM.œ„“Þ(q&–ÔÇ^ŠUé¥*½DOÝT7
ë^ÕÙØ4ççN ΨCoÂÊ œ¹òŠ.൪è2x F6€3„ƒ“'ÿ†<=Q{fæðù¬úÒø¤(|k C}Ù[9c(¦ªëßÊÈãø;8ˆ` *`\Al—#L z#Å üœKšŠ5g?鲚
Ðd
½Â¯jîÿÚÌóãfþS@Ñr«>É¡]h†@(Åö0\h 8š[BA¥2Ó£ìÈøÉht{õæ*ÆÓ,_RPbKáÃÍVÂÜÉ•”§ÿž PK•^ØY PK ú>C i Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Site.hxUX ‚IRÈ IRõ ÅY{oâVÿ;ù·^¥˜‰c2#T‘f*È„-¤ÓÙnUs7ÆöÚ×$é(ß}ç>ü dšÕJ])3Ø÷ž÷9÷<®[oŽÙÖ“Ç4Xo³»Íwçç?{wþö »ö 8»Šóhé‰ Ž IÀžnƒ,à 2¶á)_<²uêE‚/ ¶J9gñŠù/]s‡‰˜yÑ#Kxš!^/ˆ‚hÍ<"åƒ/‹
(eñJÜ{)ü’yYû’lûù–GBÊÀVAÈ3f‹
gÖLcXM‡¨Õ’{! "FÛf—Ýbç‚¥<ià@~˜/I³ Û@E%i’ŒèæT!i ¶—ÁŠ~¹Ô/Éam ¶ ˆú"XÌhÑç°ˆjÅ)Ëx‘
H¥K ©4%d\¡Í%Yßoâ-Á¡B%˜k•§s‰¶Œa>É÷wî Z!ê«8 ã{ÒÑ£e@ªemíÅ9ö½E¼ãR-åü(Z‰B IJOëlãA‡×æó@ZË«h–’™@<pF§’ï¾Æ®‘ãºÏfã«ù§Î´Ï36™Žôú=fufx· öi0¿ ßÎ ¦Ñü3_±Îè3ûq0ê9¬ÿódÚŸÍØxJÔ7“á åÁ¨;¼í
F Ù ŽÆs6 Ü æ ; KžšÚ ?#z7ýi÷¯ƒá`þYzíj0 å«ñ”uؤ3º·ÃΔMn§“ñ¬!z <Œ®¦`Ô¿éæ.cõ ›]w†CâFä:·PcJ‚²îxòy:øx=g×ãa¯Å}È×ù0ì+nЮ;ì n ÖëÜt>ö%Ö„¤’©ÄdŸ®û´J\;øëÎãéÓ æS¼:Pw:/°?
f}‡u¦ƒ–:NÇ`BÖÒXÒꨯ‘åë½ßÎú5‰zýÎg„_…''·ŽÏ¿óÖ Q‡™»AR ƒÅÅñq°¥à`´àÞó…Û ²ÄþæÂìDü.v‡[]øÄË…ì1s— ÷Mm!ˆÝ+d‰bÆׂ÷J
’{*Dàvç ¯¯ÿ‡ð2Ol2b|œgtÂjŒË%zŸ=f‚oÍêÐÛ.– ðüIŽ‘8ìËñQF©ÇÇ©Žd‚B²yb7Ù—§V+^dqÈ?~–æ á/XÙì›:W—? /eöüfò[o0m²&àŽö`ü”#Óö‚¹#N à‹¯Óœöÿ šø¢.ŠDf79ÿ•]^2K*m1¥Ð‘6a l’‘°-#ãEü_‘¥vS,¥=>áßÎKe™`—,ÊÃðB/eÁroeñ(°.Ù¹ªÕšv&80³¶LUȼ ²A: Éq+d6
@”3žqž…Œï‚P*Ål”?p?Þ"ä%vÓ
¢%¯ìFßh’Âgo¥éÑn⥿ÉCàIØÆÁvâ*‘·åÚ*Òt‰4íÖ‚½¤‚3±TÄ0V{¡@´Y*ÁêÞ§ˆ@ãrvʬ–…ÿ‰ž]±M‚EšOŒ‡gŠœØ¤ñ=KN-ªÌó}ž b[òÉ)t@ûà9Iœ9ÆH«lzÉ°¦(¯
i®à£´_ÇTdå”A"?@@+2ãš‹ ÞzÀÓ‘CN‘ ß(çQú˜´_:iòcC+K¸¦p–Ѻ1ˆv^3ý3HØ™,{10œê`ÛÐæ.áئÂ0’å1µÏ Å_ó"0Rwª
rü‚—%u7KÂ@Ø
ãòK«Ñt“¨YÚ÷ó½9/$¦ .k±¹hµNÈ [Ç*=ã`†Â=ËÅê»=çÎÐ%EkéYíQ}luVbj_™Ø–Ø~güy: EØ߬SH841ÈÚÌ:•òbQÉMÜ?œ2м%¡÷(©ãýyžE\Íù0°Y·ÔPòU\'Í
ànŒvâÁ¶Cm\BÃOÃÝ
¡LÉ ³Ý³‚¸±ËS!Qßz~“é‰Ý2¾ÂØ# ‹#FÍ–éì}ï¼ Í©ÃvƆš™r1)y< ß}.\/×ÉÚ#kƒ¦4]Ü!ö®éŠxÆ·;žÚòQùREØ“©/Ô¨Â¸ì ¼,ó,¨ý;GmXÂ7²yZÿ Û²ôƒ¸ë0^x(¼ò¹·&#àÌz³ßž7‰§ôAže¸l]Á˜-w1[ò8¹
µ%ºH •™LâReŒc²Š—z[”*GVì¦ Ÿ`™ÍÛ¯Ÿ¦qªM=çãÞ¸
÷=¢g¾§^;—l íöX„Ž:eœ0Mdz$Â’ ÈBÔ2Ñ9ZÑ ÖnÀ;G3®ÆGag…¸ÍÖµàL9T=¹Ûp”dò¥ÍÜ\56bö3ßK8‘ T÷¤ãPº‹ˆÐAQ¼… .¥±Éxî@o¢8'PDKä(
¢C´YK§I¹5¹%Ÿ Ne$ËD¡º[/rêbvÅ«ýEe±¶úy*:DÙ¨Œ]É5* Ûè.BÊ*ÄiX§„~j5¬j4Úi0£_ÒF£àˆÙÄ•NEwZÔNÝ$Æ ‹Gò™È m™HJ
½Ôß@C#&QE%|jîYu-}Ѥ·‡MšÃ¤·À{=ó×ØS
ò'Æ$cɼÍr©|®U„z|ÇÃ8©I¦í ÉEûIÙ•.Û"”dšé² àgVƒÁ_4ÚÜÆ.U “‘ê™ ›F<¾˜µ4
íßRŃN&qÚL£j]Z
ë‡÷½Áh‘áRJ³7¿ ¼ö(¡á´ŸÁΛºÞín°]MtüÛ€S…É´Áe² ,võåp_5vyAIè”9%]Û¯ÞÔ0¿z½[aÿ -D·8r_—Ä1£ß3ÉøŸHö\úIW^2Òí‚9ñÅ
£Y©RŒ#þ\³šº¼¦.ÿšºú²é¯Sö/Ò•Â!?¶|û^ˆ2Ä£ßng.¢ù»2‹å) “ßSõºa AÌÁºFm©ôYvPi zpÊ$o¤Ku¢PûÞáH•W/Š81®xÃÞSÀ‡cÓÖ0tÄʳN•é, Ù+à º Ô ü’g~$²Ã’è ×CJV¯äºæ·=§Fä×JëEë “Ð̵+}C±åõÇóë‘2>M“[½1{àÛ= ”,iSGà âDÅ/ ÍÔÕW¶£»Ñ]åî³ù&¥»Nu‰¬}
u ,_$pjý°»D}¤JTX‰7N+WJÁà[OØ´à®Òx«3>Úg¬4ÁãÄsØ g' vò™\·OnÚ'3vòÇ«Ì˜ä ¢ %¹W`x¹ØÈH2ªÈËœW[¤ Ñ/•{Ôõ-î¬ù¬yÈ2]¯÷+Ý}@¥™R·²åçBõÕÍ3:tI´¸0–_`Ug,/ƒmFM”™O›•ûVVå&&Ð"ã)º~ȽÈ|ì¤ÖI!|S¶0££9’ Ÿl¹írÝ|< ÿPKÛ±'h‚
Ç# PK ú>C l Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/SiteApi.hxUX ‚IRÈ IRõ }TQoâ8~>~ŨO°Êµ½J÷Ò=ÀëB%¡½>šÄï†8²MÙjµÿýf ´PèIHÁãù¾o¾Û7_zðFº{5jU;èw··þ~wûÇ LÅ ½i+á”n1“’SiÖÊZ €²PK#¯°2¢u²
`i¤½„²f%pDû
4zá„jU»AT%êR²«‘Éê¥Û
#1¿a.•@J¨t¹YËÖù`©i¡ïj Wù q5ˆ
¥*)P-Ðöa¶ÊÕzãÀHëŒ*‰&À¤²ÙTTÉa»QkåF=ƒo‰%ÞE+Tm k]©%}¥÷×m²u •"öÅÆaÐR°”-¢ˆ
ÝhV6
‘(4àM¿×xÓ(ÔQsݾ]^z[ë5åÑ›%l×rcZ– VilŸ×ý&KGb_ê¦Ñ[òXê¶RdÍÞï§Xà¾Xèémí†ßj‡UïJ¡‰tï“ÞoÙZ ‡…Ü·Å•ï–8rf¨ ëð<( F§×ýèøúPÇ”AžLŠ§0cÀsH³ä‘ٮ ×W<ñbšÌ ÀŒ,Œ‹gH&ÆÏðÇ°ÓŒå9$±ñYq†a ¢ù˜Ç0Dhœñ/·H¼æž³œøf,MqyÄ‹g?µ /bbž$„†YÁGó(Ì gi’3,bŒÌ1'
±‹‹kÆ°G\@>
£ˆÔˆ.œ£Œ
…Q’>güaZÀ4‰Æ ƒC†õ…ÈíÔÐÝ(
ù,€q8 ˜G%HäMRæ®Lxš2Š’jˆ¿QÁ“˜üŒ’¸Èp ݬxC?ñœf<Ç‚½Ç,Aê.‚σИ툨ó§ÂZÏsvRј…2æ„?Χ!ßô:Q~+‰§R7öºÆG¥Q‹¯½žZÓá8
_…´‡¯‰Y
–/²Ñ ;óíHžœžÒC k Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/SiteDb.hxUX ‚IRÈ IRõ WmoÛÈþ,ÿŠ©‘ƒ©TG§úEvŒÈe³•E¤ãEq È•µŠäqÉ(jÎÿ½Ïì’2å‹àPÀ€ÅÙ™gÞggOß Ñ[çÅ®”늬qÿý»wÿùý»¿½§ëè« i^gITÉ<'3/D¹‘J@RÑZ”b¹£‡2Ê*‘ hU
AùŠâuT>ˆU9EÙŽ
Q*äË*’™Ì (b¨z™¹ZIå«j•ü EJ屌 II בUÚZÉT(²ªµ ã ‘8î
ª¥$3âãö”¶²ZçuE¥PU)c†€)Në„-iS¹‘Uë¨FÐ!QŒ[+¸ÂÖh“'rÅÿ…ö¯¨—©Të%’Ñ—u¢bb,2H1 :ÍKR"MDÂíô“í4 ܪ —V½]çæe ½Kת.3(Z,É>÷WWLaôUž¦ù–}Œó,‘ìš6Y q -ó/B»e’Ÿå¬6¦pFŠ§L7Gj Á‡¥hÂåRG+êxV²ªB=H$£ÈK÷¹ÇvkǵC7
ïF¾Cn@ ßûäNœ | èÎ
¯½ÛÀáæá=ySÍïéŸî|2 ç_ ß ò|Fso3×Ùg·w~E—{!ÍÜ7nèi
šëŒwãøãk|Ž.Ý™Þë¬MÝpÎÈSϧ-F~èŽog#Ÿ·þ 1òÜO}(rnœyhC1hä|Â×£ÙŒµ1Üènøl(½Å½ï^]‡tíÍ&ˆ—ì]Î £
Þg#÷f@“ÑÍèÊÑR €´“Ìi̤»k‡©¬u„¿qèzsögìÍC Ÿ¸ë‡{é;7p4òÝ k }J8ºò4DçŽâÈ &,ü}8MœÑ ˆËwù9ɧGEŽ ª2O•½ÆPIåòìèHn¸8Hí”,í·gÏá®jO<¶QµV,R+.o–¹=Ålè’ø;Ø©Jl -N1SèV‰’Ä×Jd‰"ÏtË·££žn㘾D%É„†¸ÉÙ5‹6‚éèñìáðhU§é+ÇbÉô…³‚mz::zlí\”¹¶íÿlj"T\ÊBOÒïslÅRÉê%ùfª½„žo³4vÉÍ*ú@ïÀðqXŠTÏU ç¢ìSGDSÀÎy9äý‚ˆÿÜ
ÕÏôóOæû’G=ÅÃ;nÙWu¦'=¾æαh›—ÉÐXN} Ì0³Ï¿!ŒÚÞŽ\ë=^ ܽ ë-;“‰–°úÐ×c,O~zÿ~:aÚ
ÃÏ*šÔáÚD
¿´•ˆÊxm½a|;•Ÿ…Å2}úýwzÓIIç¨ß\zí¢Vk‹Œ‘
´-“ÖÖ–¢sþHÚ2Hán`£ñ…Šz)2Ú—»9¾öôô4ô&Þk¯È‘ä`áMP¡U¼æ EÕ…nÄg>UeÛëÆ~"ÊËÝPÛeWù,ߊr )?´«¨3„)leÎ c§™Iûú÷|ÌGº¼§™wçøƒ÷O°eD©}ãÞ¾gÂèáOõK¹NAwj°‰îA
¶é ¶6¾V|U^À*eQÖ´D§ê ¶©E^-ê¬2 MÙ5ÁŠ#UÑM±8ûj—â·{ŒuÜÄ (ÌìÛyh½ícm2P&ˆ +ß»]p ÙË}4
ÓÄ Ææ^¤cú+e} «:E6ž‡¶i´ ïŸbçxýš—&bÏdöýS¦íÁÇa†ñ-Sq¨T|‘èaØèdõæ<øe/ ùâ ¡ÎëÍ~Ú ûBƒ«Ï² g×z<@FT¸¯¥}!àô—Ì´Z“Ù*‡~p[}t‹Ðaß[Ñ)¢–shLî%CµxbèÈ
ô/•þ¥cc~§º¿á ¾L¾fyÔ½èô”Ôo)_ IŽ%ë #,§{"°À U¸´pâ|ÃË»ú±+ãùawóoÓ``^ù¨<î‘N×}ûãüyi€ýÌž Ìs 㬙^¯ÌÑå®)b‹Š§Š~U零>| Bóç<©ÅßÇ¡L,¼AÊAÛLM_NPo©Žÿ :³wЄ,|ÐLøî½ûƒíú4TÅdÉ›øèÔ-Á<γLèAE{»è— 5)¿<²•|¨K“ß%/n€8 K¼±”ÚéË'Úé×C*0_I<îùª¹Í`ÁâB—+²&—¿`¯ºW¶øŠé‹××g½› ÊÚŽ¡¯—ö?ðò²‹¨ÄÕõ$†þ…71àûú6ë \A$Ða#‹LÝ™cX`h¯3¼aP²<ëÐØ\<’ä…Ù)šu£)5 •e´;o¸Ï';L_\ çß ÏɳfÝÓMvh¸¾›Q~@Û—QKñ?û…fÓYeT¿
é_Bž¯ãR XÛ¨nÌÚÒë Åú ŽÎØ¿Ç—÷4ä6«‹}öì8ÍU—} [žƒqÕ >!¦›ÇÄS)R»ìdù––XP±c1ŠSপ~Ùó*È¥ïX÷ãÑÿ PK™5 Y : PK ú>C m Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Template.hxUX ‚IRÈ IRõ ¥TMkÜ0=;ÿ0 …H:ôjwsI)ôÐ44!—RE ïšh-#É›]šýïÕ—åµréÅËÎ×›yóF ãÏl…`¤:_³ Šæ©<=9=i6Tœ)¯tþ£3lËì÷F5íê;ë|LkxÀM'˜AÀÁ¶Ò!8YÿœždÚ0ÓpØ2uƒ¢ºa|°€_ •$´ Cë¾å®…ï¼fßaqã?Ù·lÓðkê‹g®¬5¸‚6(_¡ñq·ÖæÓ|ᬩœð9îm4q™4VÊŽÜ÷]¯Z* ÞM›0¾µ¶×–ãWçЈ†~aq
Fõø; ÜG¡éU{4¿«Ð]‹ICµ÷U‰,⬗!±lÑ",(1Ú~ýÒ¾½ºÎdMä0dÆ™Fxð N‹`ÌÒv´%2ÑÎÃYà/øêü?
¯¯0µ_ØÉ– ¼íÂRó³{i÷ñkܸáï”ìP™=‘q:š°Ph ºÍ²[Ùâà9„ß
kÖ S õ6T^3 ÉKea]ϼÐë0ߊmyVømÒÇí
qâ}/[ZÀ¶<²:ÜÚ^ˆ=ËìGnQ©¦BèT³u•úÙ°g¼cfM°x”M ¯!©EÐA9Û/Ù)èÞ²žÉ.¸¼º2ÒŠ»FÂÅwÕY-˘҆ gDœuá{u»ïòÎpžŸƒ'dPz Q䌧=*Ì í®d´eéæ:5k%_BTÞÕ©FÛäé±rìÔÒ ÌÆNkCê ç’Þ
ÄŠ|
¡q”DÖÀ=±+…èL²@BíÂi Oi”OÚ_Ú›B-ÅÉô¢'ëš+‰ËÖØçu¦§©œb;QU£¨Ò äŸ1nvî³O¦oªÖF¼¯Û)Ð iîø`¸µž/—¼W
[³\΄‡+Sb´¿ÙÝtq+!Ÿ¬ªÿóÎõðPK¥!Ð0Á PK v¹B , Haxe Toolkit Installer Template/haxelogo.pngUX ™IR/7 Qõ Ý»‡SSÛ6 ¯W±aCE@@ºtD•zïé¡#] DEA@@¡J
½÷^TšH B¤B/ $ï9¹¿™ï?øÞ™73 Ã9묶Ÿõ¬µwaZJ´/@ Z¨²¼òÏr
vî,p+›Ìü:ï®lì ÜŸ N=¿—â\¤ñ‚ª+ÐLŸa8-ų?ù&r•¦ç‡ÅOø™ pG}—ìÎú>g÷‹¹wþzgQ6g킼Ãð“I"tÜ8gÊžY"f¯ë[µÇ#hj°nTÚ¯ˆrRç2Žoјªwqî5¶šv
\Ñu™ãô¶2 ãB±+\çô»v 9;Ñðy‡´Áú//ŠýÃ$±—´—ð/`®uéÒVZ0îs äÿùOÆKDLJ6[öÅDÛÇm´ñwñÓ†
¥²•é‚ûUôb›vägä¥Çébý§…çÑæ©y¦3ˆcÕwRHä-ñöF¡õu¢[²²…ÛJ¹’ úY/7³h›±NîWÖ …aC›$ÒººuÞ/&Fx[[@ðóÝÄ>7·Mú :™$24°™+*º¶D·B+㌜!Ã)eX9õ*ÓÓ»“ÉsÚ8\ëÿ~¥)â¹èȧ…9é´HkU. “©×W¤9V,~ð·ÍØRžÒåðànV)¾ì²H
ß>è=iuë£Oûz¹#Ïär(æ(ê¯OÏÔ ‹Ã 2ïWË)ˆ:«d{£ÆW²§_ëRžPÀW¯J\åVÌYYÆ6¥Åƒ_)*8›üª“CŠžÊ„-ÒÐŽ5ÁË6Xº¥™tµ÷Ö ‹~ú««|ÂSoJóˆu× È‹YÕçíªøÕÚ?óîÇKäk©6« eà l0ÙÞ´âñög]<_ñ(3¯·,3ûXÑë´´;o£¸9&Oz2)qrtg
gÈŽµøNy ÛTâj)ø¹A¬Èþ4™~é¯GÏÖ¸ ‹ð´ä±H±¯J\§æÒé‰8
Ë[ó®.|y¸ b öðÞZçÀA¨†v½‚Žt äÆ.áÁ/Šoê°¿òF[&ÑHð%ÊÞíÆ”0qi›„¯Ê>³ný0Z+;¹ê²YO+ÃÕ8,ÚspÔBxe•‘å& Fò¹o¡ylC´j£ªŽ“ ΘYSñA™@·ö^ïïÐþÖšL
bÎáN|*ÙÔ…Ìi¿8§¯QÛ’ò™ :LáZpôûXŒ,'/‹¶|"YØãÉöúÆÜ7…•„¹ƒ'+ü2öVµ¾ÿ.ŸódªK@µûŒìRXl"Á
֕
øsü#”t¤4Ï‘^éµ-g;¿—“ɦ±µk±‹xàرäy”>q‘œ˜mêäÚ©4f#P%q§7o s$+(ñì
xFÛfáNùcU¤ÊË\Pñ`ýL/)g¼Ë~¾š½M!·–±!Ï~¼M6‚ÕM¯N :'5z'kçýñCJ±žîÚ/ka%Ù†å|b²Iªåíh‰m¢OXŽ(bÖ¬§ˆRlÇ™Ç$ðëÒ_ùÓ7t8ý£Ëz e&¸ÂØ`/çaBZØoiÓÓÀ7D«4Ö”GM{³3¤Ê ´MöŽëÒ{/{U
›p¥J¡ä„Ðl¿OA:FÖÚÍ[›æ ˆú…¼ÕíS©H1™ UG‹Ù€âAÄACÕÚ¯ ššJ·ç—aa>Ü<•r=Cã36ªVÓËï\±zDœr7“EÎ$Í_†< 1Ò½3䞤1ÜP³%ˆj† Ž8Í@ËØK:Œ%`¦”´wW~
} zWSîRX[(HAÌ‹*ð<ô‰îcÑ
Ø&7#¿»
"šØ0ÛG¿ec½Ú²â‰J¼ã½[=¿_ˆúìçeáQô3û…Ùýý›Fç}!;…ÇyäñÅWÍ_ýÛmr
c *qP˜YfË”“d€)A Ø?͹·—Ÿmkd;“þ½ùàîÜü$SK"–ÏÁ©JZ½=±1e¡â:Pw}Ù\“¥ß#.Ä;}SJoüo~ «-3°üÅmlˆFÎ8á0š¿Rôò{_P‚¦sP¡\‚’û¹Ò…2óOßvÅýÚ·{Õ\ü’"Ö’4^¯Š"àߤ;¾âÐm|j•TnØð##g>ç#Òdã`íÅÊÅ}Môh§Ìnx%ß_B|h´ŠA Ç—Rít5ÂÇèE¹ÀGu=½cëAK¼¿ª¶î7N¾¢‚§ª¢Fw>¨ðý3³{ hxßdIiqܶ®¶êvx%:C¯²å¬ÿ{ ¥ÓäfœîÚîäýñ”þ&ÍBõMXÛçÇÀº3«Åú£b§8§»„| ,rìü›Áö›0Âb1pÕ.æÚ’‘“;lO¦ó)Ê…Of+-NÕlrq˜r‘â²ôT ®ÒåL@oÿö²v£KLÔ̵}Cbè1¹fEC7K
ÒÒAòÝ쥈ªÚrò ד2¸u'îœùp짾Ïgz^%ÔÅ£Ää þ_:ÀßP|ºãŠ2‘ÞdùÙ QÓ ³¾,z’OârîOCèÉÖxî‚•Íy§<]¶´
*Ö Ë—óÓ#Öò݉ ø~|²ý;•üûG1ò ÕqH ¬2¼tJtƒn…~~^ðe`öždºš§ ¢¢i¼œVyÕ)·[þ4D$%M'ôrõýÐÎ —ãwÙÊrÚâ3ó“jõ*¡ÃÉw럾se2Eg GŠ4qã¯õ,‘ϧº’æc•¾
*‰&N/~5*‚õ»³ÖåèTê… îÚ™òqÜIÃóòWøäÖØ(\`ÞWc$|:Lî=¥XÇeNÙ¨qNPˆ†ú÷®Ó¿ÓÌE^gu ›Ç”L ÉûŸfò ó¡ŸÐ;ZPæ^°¯Wþ )½#Ï
ápûÅéßOFLrŸÞ§5v%ÂãœQæûðÀ1 â/2þà¿¢âŸÝ÷1Auý©Gã‚û£d‚²†]¿Õ«ÚÑ'ö÷ƒÿ&šoˆ•€°ÍpóP/Xçñ¸dÕðol %sÔpOPo—Rnt.P[ÍÐ変’3ìØKŽjÞ>•N¨W ÊÓîê®ì\Á¬N¨ÎõÉõ
Ü›ù°û !ì\?Êì¸Æ߶£€é‰Æô :”Z;Pÿ¯ü]Ž#QãŽÚÀz —A÷?d Òd1Ð4w×;1ÿ~¡<¥¼,sw‡\Xá¾ã“ª0Ëb¯ýúã¡ÃQÒ¾Ù eç6™«·[3í†mŒj>*„aRÚŠ1(×»@Š¾|ÌÚ˱¶ž…y
=b$Ð_§ÓÓ_Z)üÀ‚pyÚB+á9ùŠ
æ›z©}²MãòÂTlì¤à ý2óÌ4œæ
0^'y'”½8÷ðgI¿j’©þÏYß·Ç W/lS&Ói) —ÑœÐFq
,=|æV:Û7tóC '2Ýe=pž™5Û5-ŽÛWžr öËô·LB´HC0¸ËVxIJKȇƒÆ_ÙgdªA(Ì´I#ªLPt—²Ne¥ú•Ñ³ÅòÏ^‚ëuV_¹Ù5xwH£y"¨F Ý“Ln&ùºÈ{0f+ÓQ >àÂÑeAuñÖ½gÃlÑ`xà‚“ïŽ†{u*h`V²¸©:⾘Q5 ¡†'ÿOXíýs`o|ojÊ'òîìGŸ¹–\Î3S‚a9Tåö©hZµÌg@73‡å9ðbĉ Ëv$>*—ë‘ýÔ¡PUÓ¬–ù¶˜\2 Úož÷ᢆÿ)¯ÏBÙ_ eÁw¡!Þq¼`ºô”T=bÙÓm®þwýœõø× ï…\¬æÆØžÛÉw±a 3‹t*թϨ” $ä&>•'un Í÷÷¨ÚŽú@ˆR#(¬øY Í+¦]ÎJ˜f“kŽÔºª:HÕg¾ÍØ÷“
†gþ&ÈüæÁD ,²Ö‰…î“o7’ C9SǶLŸÖ$¹ŸwÒ B!ƒï€t ÷ ‰«½³5êªã_À¨eÒ(b÷˜ª§\OtÜt¦óv² Çqƒ†Kÿ-'°l_rlnÎÛ×Ù%ªßÁwx«Á²k64_rD…
ŤƮA)Ynù‚3ì=Ip:%Òû4î™%a†JGÇ$v@ËSÌ…F%—1uÃN©è»X%’ÓVkšŸÅ¡û
ˈYôON
híip¥ë^ïÞ÷,7{ó•G8_Î.¿3“Z}X¿‚ÙßýbV«¸ë>þN†kd¦@®`ª˜¢ïWXŒÍE\ÉîDQkПF C+úS?—LË gÎÚ¨mÇóy‰Ü`>^LÜ»W“¸á½áº<ýÁü_Èë ¯Õ5Ùî~›)f,Gú
ÈòR‹'¬¢ä"rÁÅÂt/!Ëâàºñuvù ¦A†XÐô«
ÝZÓÒ30».ô$¨ ³Î
L¨7E» P ãMÚ¿±.•]O¢Å@Óh‘ì‘‹Èa"¦D“ „2·W
e4þSÓT’¢©ÍjLúPjôç¡… ¾‰ìÈ&Ú€ó@Ç^Þ¿L«Òˆü:a¡{Ç* •
VWº¾• Kà³µ)urØLžo ¸•¬º,Íæ`Éš?z³Ìþ5cþ Gu: ›ÅÓ°A‡Söq÷OÊ=)¬û7¾=8 yÍüEO;»é–×B .ßÌ
—€}¹J¨Ú~Ëu±1mª¥Öúš'x†ŸÛÄTkCÆApƒû¬yÀ ç®v85qlw K¢døÐ¥ñÓûòi”ÊŽÐÁØÂ,æ’€fo »!áI™Áý÷W$¦…¾Uù6þ§Ù”Ä…š1ìã–àMFn><èl¢wfSýAvYÒ¥±pmœ¶?xj
Ÿ ™n»ÔVÇÂi¶‚’ÜYõ'ž”é|˜ƒ+én0>7µd<1;ºŸä¿¦b-/õá€á_VÃr— ™±ÝÖX*-‡’1ÙöKÞ©û?j@!Õ·x”XúÁÛuÂÏè‡x¡¯Uÿ@^7Üíõ®ãLïvî&ßaBmƒÝ3z Ë$ø¤K·T#ÄëÉùU\ÂîØ«“JsÓ'ÊÕÁ~mò 4žmå'‘'ÈáѦδw2µƒb<7"Ót¤†.Ïd-)hÓpáD–œ
ëC‘þÈ—f£&
e¢„gk`.û;ÏŸ«„%ôá‡~ûó“é^ˆù?Uêm7 n>%¹û°ä·R\âúaäùu e{ß}&K~CV››$ç@DÎÜ×5 nñl}îV0#û! ^Vã'!eV7Àj8Dç’>oËj±L3¹IåÆèhz(.iÄvj>2y`þÁ§ïÁœM¿l‹¥«Zµ´áÎKY˜cÿ“ïgA ä?oY“CñyÖÿ–ôî ~êÜûõY&±O YNŒÞÿXQ¶ñ[8<3Vp„~Ékrfî> ¦¿±>cÅ 1°ÕÂ;‡râ¢`¡ïu`٠ƣ_Ôñÿ˜–—J–ži)¶¾€}´¶Ó¹{-Àä<ØJ2 ÑŠ6ÄÃbz5’mà;¸Òƒî€{pÊ4}JÍÚMkgèU«Ï‰T¸/~£¶±9€D7)ßÖ®AþŽÂ>›ø=ÃP"ºŸvOõû,&ÎXÝÅUomÜ
è©…í7p’Tº'öñVÖà¶@À¼ÙwÕmÛ ãfuJú΃ òÚÚ kUÍ-í5³ ö4ò¹çµBï2 J÷ ¡©´Ò+;/Nþ–;¯Á6`ÈVcßµï%;Ò£Lü2W´—•ÀLÔ…" ppu@¡]øߢ¦ˆ{Õòiñ)†$*Ù{í•6qv& Ï n Eq‡ dTº5ìŽÈ#ÇF[Û¬Oƒ&‹Íê|áyfH¿ ·Å؛«xxˆßtŠ£Ž_h«D§|—Pa ¶&ƒ´µy”†Åœ³‰>ìç•$6l…ÕÖ‡äýöº´u2qæ´ó
0Ê›öÓŒñNÝ\m¦w ÔÖFï
BOýžÙ\oÞsñß]àl“ÏœJDe§7ˬÎ}ð)vnæQe%<;£Z÷¶ðmBŽ! =úBd°S±!þáúæ€ñ˜=7usJ‚CðUs¨ö” /b(Á×›·©P ‘†?£J~>œÞ²A¿ÕXc‚SÆpÏM‡ZP¸«–÷§ ]jé ÚÄ;‰j±ôòêš\šÕ˜Ìù–ìHzÄBÒÏ2 ™(IUÕ¥ }öÆnÃÅÖxuW lÑÑ}‚¼Ô›}é)5^,Áuí'IåÜWÙ¾j° -ò€õå•ERŸT˜Ï¨J³éÍyéK¤÷„Y÷“<}ä0å@-4¼ßþ],'×–a;®¡~ ïð»2? 4CÑÈÖoˆ>rúh´†4×JÙÀ{€ßJÕ˜Ù9i¸ÎM$^qo²ÖíŽL—hp•'\TÞWU%7Ø.Ø$6(‹9òAƱ‰s!—rànŸsÌ ö-¤vµŠ,jíIi«}$Bñ`æÆjmm`’ ùJ
óàW8tÕâ@¿4Š” ’;=1Ò9?_)‘fÃáJ%]‰ÕN¹” æ”+ÇJÜPPcÛ³ÑÌg
䧨âN`¶˜ß óAsd1?d ÀjÛ=ö :›ËíµroxÁ"Ó ºS^ö-Sóä½êOòR«l3ùÂd9¥r•‰ÔÚ» bjU6D‚}Z:nÊG‡‡¿ó;x[‰â‹¿ÐÖ=
Þfä Áî}Ì–5 h†¢èðùk~¾è«).Š¬d¶-4Œz¢ŸÑÄå]„©L€+Iw7EO %ýpíáIº.äü{º}Uÿ'&†þèÿnÃ;þ¦¯’‰_Dt©]^K:ãg% zÉïŠB„ÔÜ8OâeꃊƒŽ‘¼ ”¯Ã2òÕ¡ù–,:–ã^`.·jpçiâüàõV…j Ëü´Ü.~£lÂKG½uÙ:Éèe>jØLS%rí0ƒ , îûYÈÅØÊãÕð`¥ Ä7,~ÐÐù Ïü~ŒT)’é¿g×tø
|_q™Øæî”r*4cX²¤>è J UZD[p÷{m¨¹1498Z‰÷´G³ÍhÉŽY
zÐPõAÇì ¬ÊÄ)!?9¾(ÿp ¨ŽL±GI‘ðË‹ë¿àå£ï-gGW;7 2uHrc¹x1x»¯Ìc4ˆŠ!öü ‹Ø]ÙWlž/r{¯ò#à œº&¼S\; §+^JÑ»øÇs ¶¶þf¨oO×lqƒJ͘EÌÉzkòNx¶×æ¦C.H¤ƒ·»¼²#QáAÅÞã˜Ø)Gi,ôÎÏ.t ÏÑ6yÀ¯
Zl•ƒ?_ãDÌ©ÝÈññ·rñl`ÙŠJŽòÞrHU#qò†¯["›tÔb@Ñ .-PÎ÷ GaGfh¿îJ…€É³‹tø¥ý¡[R|P¡iÑø úXNBnó-ÛsìxZ܆¯¥\®Œâá²6+GŠMœ¯Æ¥~žÔ ñu]·É‰uï¦\©rLZœ
*ûÍ7yÇöç®~J‚€lNe«ùvºª à!¬KíHÂÿ<3·'ôÊr‚á®sÌ5·ð¨¿¹ÅJµk5ôÅ>›RÄRÛFªÖkòyc¼#rKHÁÇ£Ë\ÿIàż·û™÷Ñ‘ñxý „~”ávèeÁ°Gw”Rør„*$Ë<ðÝÉÏoRÄ™¾l*éH…+Ö@‡i„±6þ oELj €$°„Æ**’^ä„¿þ}m§AÛW¯A—lwzºÇÈl€v tñ›9jÚà°¤µî¾7ˆPì%ÌÛ¾•ýˆ¶õÓ.)ñsK×ùï%_xBi<ÑÝÿÔæm ¿BõÑàvC¥(‚ì;·_I™É!6tH<lkLqÝæ;h(ý+ô )»0Œ”±‡pƾ4£UV„ø zû”ø¿ñRØ<ŽýŸ–¥”i ÿî\þÉë ¯5×”èLx ºsZvëJ`Q¤¹{+¥œêÍÖ“ ¬d÷*T¦¤8Mƒ©TÎéÿT§{ʃ¸×ä=ù\ pHB ~UÙŽ{àÓÝ…w¾ F‡¦Í~;#°’n±2Ÿ$½½p"ÖlÍ•eŽŠÛfR“ô#d‡jVÙRÐ'3îë'¥ê——tù=Ú>øf!0'fY¤7ªAÓ^¤ïnû'L?€ßö㪴®sZå6ܼbáT‡ÔP+ûö¸¨õ'Åýò6sÞZ†¾l+;xÿØÝüˆžêÔ^
ŸQšK…[¸>Æ ˆ¶“ýz æ΂Ô!=¤ÄU’º2eYîÍý6Ê›“„=¹ž÷>ÐYM£‰k¨ˆ-«ªüI¦X¡:j£aýýåZ˜ùƒƒPöÁ“2In¹Ò
‚J ˜Kü¨G’ŽÌ ILŽ|›Ô`ª §m uSÒí„å¦xAeP¬ºBoro…Õb_Tn’œÜL C¹$€QGÙ w¼ˆÝŽ™:í¬ z˜Áe¨˜;ÐïÓàþ(½l²ûió%Ȩ`.;±èÐ"Úk»!ÐŒ!ô;«S…ïâÐÕÞñ6I—ÊÝ
W69fÖ¤± ÞÁÛ§=2& 8å².;†žDbWA.s̯F7lÁ‰¼u•°Ç„w]síÄê?¸
‚#¼V*œoÙ J±Ò ßp›62ŒŽó¤b·xõamÞcîl zÚ©Ûkã (Ô¦)]°miÝ`áØÒ¨>ÕËS´´{»ƒ©ÅzíìB•ecF¹¦ŒØjÚG»Ü½N¨©ùe”žÖÎÕ4 «YÙIY4‚ V2`2G±æÑàýΈ¯”ölÌ>
èÚøUŸ*žà”‹<>iÍ.Zô[¹ÆÚ7†ð»
(Ô·]ðl¶‘ô;3§–ä-½ÁH”Ì“¥Þè ß^´ë‡nf:¼¾Õ+œ—]Brï{ïÿ`I=1¾ã¯¬Ók&ÌUrAÀZ™ÆûÒø£´ÇO*COð*`ã|ázJ°L…ȳS¯rît‰)“ëe …°È‰/IˇOöL»†°O|YŸýóãûîrsé)W4&-ä3
˜ñß;™öA¤ÏÒ~ÄŸ‘©ý²à±GßXþ Li !â[™ÙŽ"¦Ç(Lýåë›glqÐÜ YóKßµ‡¹c¢øD Š\[C+ËÃ=]ìpm ¬êe“ý!3bDÄ‹\IÄSƒ'ež¿CMÅ%ºý@ì¾Á§]D ÝFp@ kà» 5 8AöðC(G.«£‚f ïô7{ä>H^¨¡}ýs©F;yçñô@cÕfT«HcjòÝ“Ø¥[?á’zbÆÕFú# g—zØK+5¼¤ÅÁ^ XžO?ü»Ÿ—ÚW† —0U.ö •E«4:²Ò–-*¥È(‡ LÚëÕÊõ³àQÙÅ8ΣŽ~´¸ó7€ß¥e$;Ê#D~™Wh¦JmÃÝýÌ AuV¼ý?Í
1x³Á;ÿÃ%U5ß°=×Â-¼ÖüÊÚmvÐKÌtÌì>J0£bÖz7w‹Pä„3Èú…«ºœ3aû¯ Šˆ·`'ä´
)qWê@n¾‡
ñ·•+Çã_ã?9À´§UA ‚³ƒ/6ûƒ©ýÃX §‹©|*@ÒûÜg¡`¸öƇEjuÑÇv¸2brF‘«*Iä½,×ìDlAG¥Z,‰»yã
ï]l®¦ÐÔIä8«Ùb¸°ó·¼GvMß]ÐÞKlVŠY²IG7• ©ïÜ1œ'ò&‘:gÔnçûĨ‚;¢ ‚Ã¥xÃý?+R>Ô0êÕžiªD Ó8 [ö¹hI”&ÑÃDඓ¶u=_Kó.ïR·~Öõ†Y¬†ä5lº ¿Ð»çÕš“YTºÆŠ:Ä¡*柼‡ÓCî&0¤¥š[‡ï‹Ä{t®Ô¯á鑽Á>ï+à}Ý£E¼S?ìŒfSÿÄIçeHH˜ÖWé…¼~¬ µtQÍò=Ìíõ„Am.ãuÏ¡ÊFbÀ½§öÙ—ôËMÒÅ£Ç
8éFÃaÙTÿ9,åk ëË•õ‹5Ÿüå
ù•ÍQÙÏÐ{*·ÃØY«ð,£=&°ø,MqÜ–=ð†G¿ü Ê•êò^ÊóéêÖ—qEx¸|ªöéú{¹q7 Íz¬[ôàŸ _fâE\¦Ä-C‹ 3“\ozólCÁÕHÿàÑ¢Žëø˱â‰7Š
¦ØíÚu"¶WU¹S6Ï\La î¦>šÒa˜˜ý!1áöBG•G
ûæplys7E¥NÙ1µ}LÑœ\U°M· Ú Ï9<ûÐE÷h¼ûÒAhí÷I ß¿¥ÛGù©8øMSß°ý¤Øqá µ^K#¾Ó§º!'Zµ×gaýI]â·4¦T{z¼Öc}RÍ&T“×’Ì®'‘Ùå|…\™ÐÂIu€¦š2±ïoB)¹kˆ‡ó¤Vˆôø‘OŽhí(‡‚tOfKéÇø|ly`ˆÆ^:–¦Ù
Ñ¿›H}+ ¨CÎ¥DͲ"'h¦€1TW:í—´Nð]«-Ûï©Ž/¥ ͤ‚´‡ÞpOÚ¯M7Ìwž ៳Ž¼šE5Gãz)½ær·¦XX« ñþâî4iªø`ÎgïR(6qS\
’±rú‡ªZ,Ú$"Î(
Ú¯[<ûWÞßðƒB¦„J£Çµº}”Âþ×*ÖŒêápMØÎÚ†¿š'…ÿkìýúTjîÌÚ¹XŸ*3ŸäWòÅN|2¢¼È07OIe$YèwDÁÿ@qš·ßö“Áùö¡K‘‡âíŒôVZ¥È±O<ëd¡ëáž»¯³¯ùý}˜Ä‰Sª4®ïGÐ7:ü0\ï¦ñ+m³£Ï¬Þîé3Hk`”Pµ…@ê?þ ;¾¡›˜„^7²©¡ô0ºDdKèäFp4[ÍŽ±È>Ê2–eu:ÃBŠJµ…FG͖墉ï SwÓ$¬@‰é]Üj’ŸEDl—?úK¤]\¡ájñd ñ nØ0nßß+„›þœZLVÖ01iüCK}%ÃøÛt÷0’ž¢Op‰Ü¹«¹½ ᧔þ¼]É—<¿ÆcS;òlT÷e¼kÂe{Ç°m2kY*ÛöÔW¨~â?@ç[’³nh¬v{V¯ø‚ï¹\}„e\m ‹ð{õË¢‹/üeWT)ýœBĺ sô¾ìH Iýd©Ô"‘øía›en(§y] ì´ÿ|†…wz]µZꆋÈG£hMì>ÚÍ°F)>òl7‡û8LøüéïnÙ+â,Ø€ge&³MÞÏK5Gç€5²I6côÃÊúî¥kÖÈ$V¬‡+Ë4_©˜–ô×åbÍ6+í &vf¾HyRºÁä˜@¾©m”g5/ÌiYp (ÿ×5gaýÖª\lÛ¼«fKó“<ÇÏuY}2ô"k"¤º'{íÄ·œ&nâØV#s²µŒo¹°táâËÿ«þ¤dä´d> ª$•Œ¤¾-uƒM6±hRBÍ¿8Æ]Ë|öÛ
oLü¡^äņ d$Ã7œN~“Û×Õ«œ2
¹ZšvœX®ðRŠÏ4~óå• ›ÁšñŽ”'àmAî‚c¬L
ƒÅlÓùL¦¾“ÀÍÞ`eB\`}Άe€©_Qo+ðjЫ¿Š»#3º§x®+ì$ (_„ mÇÇݶ”£¡XSYGµ
C[¿¿ÙJÚÊ•×|…¸P̾ˆ¥Ô± ÌcàÕþÈ–Äw9¢×¹¾_²´2ã \ŒA!?)Ws¬Þ¸21:,(Af˜ì‡” |£¾ kd«÷øH(AúîÑ*ck KµfÈO4‹I¯ © Åö¹R<õ±HÿÊ]`ê?t¶!çnK!_¾"¼V±|Tó@&ñàåZ
À+Ò· hVïU#z|Öªxôqßéˌщ T}×¾íÄM,zþÇ1÷–è|ªxT·3u ¨ øXl4¦~‹+Ô$aa€l9|¹£L14§×¨À PØuÎ…I"I%ÿ= g r@:Â…¨>< £ÀV–Ÿù¶´ÄÊ’ÄïÑÖr+Çý7åÈäÂÔ'Qmô ?°+Š2‚œJÀ4®NhæØÈùQ7Ñ©R\²*ËQ[ᎅ5.ëEîݾŒ»†¬ß¹Hca7` ¤« #õr#;Ìeu}ªª”æ/jK~œT¿°šO ¸7%Ä:$^Î g¯ èì¶ÿ@šš¦rà–Ò _>›sÑGPrH<·&¥ñÑ,~!Òvï&˜ÃËÊ^录 i”DÜ®xëÃc=ô)º ÊTBDàr¨.êþæÑïØ`äMØ*1G!û»»{ ÿçYZ•L\æ“ùǖÄš’UJ!^ë…[AæÉ~ïši ßJ“±>{_)Æ£_ÛbÉþ-ÑEWkâÛJ5b€ŽúöÌà—YØ‘+áYd^Y
éfÉõ }û Gg¢^dŠ~7+òšÌÓ
µ •Õ"0¶•:&ŠªÀÐŒˆC0ôë"Bl†gW:] ‚Bh}«ÚŠ¦‹‡\¹¤ ÔðWò²>ÿÀ.’ýÑ,4¬zéÜ~ýL˜Œ(1”vP£È*` çbP<Ó»ñå™\
‡¹æ n>•X”ÜÝžPÓËPD=ÍÍùÌшY¿B¿™• ‰åÛä N’Ö”5Mš}t¾¬ éðM¶ŸÌ«þ²¦5mhäõRÃϧ´¾ã”Óî[ïwçÛÂ…–#FçyIÚ ®Öà
E®5<0;üÿ:ßÊøYä!
'"㥠Ã!ò¤×íX£ pñµº={㬿_L^õ6°¨¦ÝA]ÞÝ- ¡ˆWÔ¯6@ew1¾œúï…²cwrá0¥n5º}¨ÏÝ[ªeÅ”ü7¦éÂ…ýÁÖ v -ñ…&ü ¦³«ñîë¿m£›WÆãÞU^† $‡‡:gU}+iþoÿ§ÀÿO ½!Ê•¶[Ÿu¬˜À¿¡
ò¥Ï_¼ý?PK1ÏÕ“. d2 PK l¹B - Haxe Toolkit Installer Template/haxelogo3.pngUX ™IR7 Qõ Íšƒsœ]Æcll7¶Û¶í4¶µ±mÛlØØhÒ¨±667h’†Mòåý/¾3ó<ÏÌbν7~×uf6FUY@€€€@‘“•Tÿ|¾üw!À}Þ£ÁúBŸDY=÷Ï÷Wÿ» Åéò|>_„÷S’‚ß‚%€ÀUªX€ ƒ“ÓôY¿ìú‚ôŽ__W¶{ì²ÊkSäô·´£6³°P9¿Î†ì
Z æȯO„Ü *’ÙV‘`"„Xd»( OË-\yG¼R×+Cû¤ŽL˜b^•/›™’%(l¹u\·kjÕ^lÛœ$õÕQm´0O¥R7ò$}ë2jy0¾ ®zë]¿àúü,0Ùx“`t ·toÃ)-D©fyvâ$/Ø®¯™ÂßL7“
ƒ•äc‡xbpñfˆ=:Á B:dydÏšù™Aß”óœ»óþ|Ü·MsÑêÊþòä~o ´?4=¡/`&,HÐBõZJ ¸4Ì¿q? H„µ–DmW/`~o$#…AEA› wÄÎçƒö[Ú±×Ü#b+iàh\A⇙Tº- #“ª çpø[i¤.Zï-6I¿;üÔ¤H5-R€š£À<¥ß§J
½4ß¼ 7] È¡;à {pÒÞ(óÕ@빞±"¯>ÎýŠC—î0”müK&ŠÚ>¯’DÎêPŸn]Hwµ zº ˜:;
¾œw· ±$ï®tc"ø¦’ŽÙ =)ûÎ÷{€òCß¾\ýËL3iì±9ùÑÌU EÖ Ç|®ýw²óC/}ØVz2?m€l¾•K:…¤Ø×ÓvÌC¸\(Tÿ™±FøwQT¯s¾ )ã%Ómvò¾@(:ë ~¢Ò Ô)xíœç=ÁYe½HøÐ~¢ŽTx¢ØšL5Õúlë å4Wz!-» i—(˜.ž0A#–8š IõLWÏÂÓ ‚ÇT-ÌØ–*E«Nk4f41ž»YnKQ_|˜ðã7W›_¬±Ð«vzQŸ®þ ô1“w6èû%ˆ# Ú 45À5à.ƒ»Ì'
X«+[("DSÖ¬µc ï¬ñ]Pb0¾£ê9 ÷J²òÊþ”Ú†YéÍ Õ9àvã¹VV@¬cžúŠÛSyˆÓbê*œŠfã+‚,³‰þ’Flj@þî ñ‘Â*¡z »%}¡H p¼aw3ùvçàÖ”v‡ô&ß½üëà„òìñ„*éû—æ×c'¨ÖbÙµ¤ì7™kB¨›=f6u®Ù&MˆxµìáË!®æ!ÿ ïr$](²Õ:Ö[î"u4?q øÜó¯bs¯XhýKšUZ1¸¯x˹l
Ä 6Ç,w%žgêáݯÃÐ5á ·öï»âÒ§ffl Ö5i I@¨€ùt]{Ò\é«I¸)x^s ódöïσ U3c¿>ù1ÒÅÃ,± ÂtsáµdÃ³Ä çª° ‹ÓåSêŒ ’Wž*¨Àè?Ó ~½zíMÛÓJ"V »B_>UiªAa FwL^ñÝýèzÀ$ünøY'Hç´°ÖÉ€‚Þ'œOà–†‰#ùiã€ÆĦÃf
ýqžˆ
|³ž9¢.üF¦¡«ÊǪqêH~8¨à ,è=Ô`É)æúWCðH*³5l ÌPA2Q§¡“…ÛÙÜžÙ y:˜`ÍÓˆN'˜¹Ì9ãâäXInŠ9|µ05XzãáMšAÆëÐSýà7·¦ Ɉjò‘_=oCëÕV-?¬°
˜K~Œ.Ã}2Â8â6íùÕ{âa¸ÑA% ±¦¬jK´ÍÊÎú²Æg¸ž¥çè‘c ÏP7!ä 9ÙûÜÂéb Iד¾¤æçÙÞA"]‰ ¦&ȇJ_ÊŬ7_Ѥt±.7ý&¾‘6—Áf‡˜?!þÆ¥åéð«dÇîä$äú³%
xßE—„«Š6#frq0Q©ªxäo”¦âR ³¢N; ?p}8\XsJë?âëâlí8Ëäíô»‰áHt륌€
ÑB:œ¹²&vú™©F)¹Vv{SŸ·C¸é T|K¥ç)Ý^é@Rê?€ãÃÑMtĽAœâ +T-‰ƒR’
4c8FxeiYÕ÷éo_np¿=A$¥ˆô<> ¢¨ðP$ª‚cW™½ß·Ã¨áôR”Ø>àÜŠÒå_Ý¿Ð^Ú² §®'lÀˆ²µA»É‰MþRüg3°X:®àx˜ª¯rÉcüX§XAAÑý^r'_Ш |Vá×âá^{§ðÒo¦Ù† IÆdo:!®³‘:î‰à([,•¾_ëØK‡vBòÚìøÃú¾§V°CûèùÎð8†Ñ©‰êÕLgGt’SE9êWNþq†øŠb I/úÅž?³
wßNm•w¬cï ² '¸&Lè²mɆ]ÃNT µI38ÅÆ'q|0|…sÿ¤K£GÂÖÓi ]„S=HÐÊH€Å¥L=—<ø7ÚAâÁÑ’é1˜FG ~ðâ£gfŒ2PÕkæÔ~é×·Q¾8¶Uä#Oîÿt»`w
Ösšž?$ºÛ€^äµ,¬EŠð.üâ«<,`;zwE輕ªG=Ä%œ”¤f0¶›[#ñ%1h¢ìƒF/°ÐN>·î\hžgªJÃMÊÜ•(Cå?xkí._ #Š)y?¬)5T1WXb#A_ Úb¯e DKÁ»pø'Ì·¸:ØÃXÈ¢mg(íSÀ yÉ„©•p¸+ÚþBÃ$îF¶šrR¸«« Ò¨`¶¯¹ÅEsH]ÎkR=Íé¿—HoлgD\ÂÙ¨
c~¥¸d I!Øž“R?ùgCÂÉ(HP,´WTãpral©jÆ¢w¦©+*¨+nDo§D=>B]Ïž€jÛtŸòR®òÒ3Ïó»°ÔÉmÀ§o Oœä?4í¨Júµ×‹ô+Ë á–éÊ<ªrÕ/…ˆ{Mp+Æ¥cò$>ƒ™qiÞ’kÃ/ßUÊ/Ôïñca ªªS
åS |¨-¹/o~ÿ;Ý”ù;ÒD=ºtÉç*“=è׃ç.ÅŸíÂ?*üùÕ|«ÿÜýÀÁo p9o¹â."‰6fwkrüÛøëjå×Á#¹?°Rºìâ|HÑ~6¡.·qü v?Ç*¼…̵ž|xÂ#GEH„,3>¿Á Â:é3>xÿ ìu Õ
ñÉæ&åØ3ö’7íxáú R;4”ÂL_.ø‡Ó0? rPýŠ˜ßzù<Ìñ i+(¤,; ßðŠd¢”ßÝ^¡€F¾¶ïÄÛA5O";Ïpã(‰ ?÷ú
CÔ2ËK¢ë
r t€}ID;SsøPûxÅÃñ ZòG„
\/ ß,(ŒÆGì“@y£„3‡4 hÿSml ±ìþ‰ðì~m!‡-=_]YÃn^*×>)ÎÿòüVGnq×)UUëY ðбYúÅLôñšÖdŸ[ &en‹y~®n>r$ÏcƒÇ® +qi‘pŒ®*vN,¦ïÈ(ã¦N° -µa&$¤å_c a£‘YqêuD¢êyºl3’ZäÊ_æb|y+CZÑ„Hð#‘mãnû 4kqLMm\H{¨ª<7g·hõžÅj ²»&h1‘×p{c +à"zƇ=3R×9ïBÑgN2s«BT@,G–Q\t4Ý(Øì¬4yç`ÒU=tÙk†ð¯äŽþüo—ä÷½Ü[a¦Ì_ è‘GÞüÆÃk:ÑÍ0"û.@è‡'Bb©ì¡Þ½¹jDÄ‘n„j 3yGZßH‡\É}¾ ˜¤è¿#jx†#}¿o¹ë$ÎüRS©)Ã6ÏFÉ»)Km«à°¨•@(ÄRÙ8ä*Ì'Œ‹&øW%)¯6c&ÉÊ´›ÙËÚ(NrÚæê1;…ó [Nž{¼qø®“ÓÐÛP61)ƒ3¥ÙH:’]Ó½À0{5ÑÏï 2qýü*.ËŠ*„©®DÎòçØ'FN 7íà›ÔåÄÜw³iM#W™«æýù iYL#tbY.zLÛ]f·áIõ[ún«Î@.˜øÏ@´µ„Ò—¸Ž †VKó—u óƒ¡bNîîóc–R?ÍC?Qž÷CÀâÈ\¤l)8ÁYé:¬?±€#ˆ9`.¶\¿Tf> ¢KŠ9V%9„V Q3Kþ± Xê\æ*¼%D®z ÷åóSGJŽ?2RúÉ^™‰;íeÎé(·n~Æ(¶C
÷cœ4ûÁ£lIχŸ§|;5ñyj³X5p(_^nŽï`£tãÔÐ$€ÉŽDÿpOt´˜ º©úêyÊPØÊXð/='¡€~ 1gq8ÎF ! ȆN½'A¹-78_4‰£ ¬—Áä[º“. Â
5ÍÜt ˆí¨>{ x0ÓLó¼´—%¿ÖY¸¶‹\*^ÀˆmR`˜àÛèòrëìÇÝ86˜ÖeÉÚ
Ù«&¬”»8מ®vå6\¸£®-2žh®Õ¾a;H<ì×æX'v•Õoý£YýÛw2—8ªŠa”õ•}Æww˜¿JÜ•ìµç7É… ·ÂŸvþŽ‡€ë…†Ë”j‰ Iûr±µÊ’1 Iqmá©=È`¹ðÄ:x†ß¶Æ–h–-Q…’æÿãs«E˜x´öm™yÁoÒpÖMpÞF´œßgüÑ¢4Ióî$MÜ ˆÈpÔë5Ò¤ðï.?q°-LX-Ëí»¡&x4þ´ã„ëªÍ-{¯an¸Oµl«¡ï^×q¸“~ß1ú®(B[¿%r)ñÈèãá\¸òuЬx¢üÐ ØCcÏZ!pxTÒ¯»0·<Žª6g)ÕÉÍ•¾uñäŸ;»fÛ¥Pø¼Tú²–Oû‚ƒª©.ÊÀñ‘ó½ù®í/¸¹ ütƺ6‘i£Cæ3q Œ‰XVÔ¥>^Ob |&8r㣊Ÿã¯MbQÍÓjF«n¹$¿rðDÚ‰7’îãíŽnö7"«N ÙÛþO>!͸3çÄøü˜£ØõÖÏ[} Ââ²b(ûÝÈþðµÙ©R/Ë[ÂÙ ØØØM¬AW$7ÈÒ÷s}+7ŽzÉbêÔ¥è
óÈêª ¥fÊH}íŽòè†vï¨
ã)ûãÜQk%»+J*(ÆSÍDm‘WµòŒ +þLa…Ä/@L}Xº«þ/Óg‰ÝoÏÅëuèFø?z7«ÏšuâÌöKÖÅ7|Nrü¿9]œôä;ë¶
]w|ˆ½h¢Ë6 ~¨=_&±¶,‘Ç/,0ãn*µ*HûZxæE½¨cIr‚›UnGŸtý5pœóœõʪ‹§ ®S ÃF\"*·Þ~îžVWœƒ‡ßL,ºø~.²M»„í}PÜ,úî LFt‰j=Üów¦˜Å™êŽn¬$x`{èåµ=¸ ]L«B¼?}@ØEµÔ·¾‘¾ÅÓ¾D¢¯´¼yîf…D䃯 X8_S® ÎPûÌ,c;ô|ˆ6šÅÔÔçç°ëδú|ƒ*·µ
r¶|Žîªg¦QÞêP¸æ-ÍU³)wœ^k´È¯×Ct†b4
Ïšgs„š•>HXñקiÞe¥Å‹à}ÉUsKën÷iÃhÐAȦõ&O>=ë$ñ¼É»pŽ9‹iýp>T
V\|ÆÞýÁÄ…D½Ï m T98±¾»¡ÓBLc/ë³}^Þ৿ÝéÚÚ¤°CuHGÓòaßÝ> Gûl tU%œŒí¹ˆkÆX D¶i«UƒH=±,£˜ÍÚ!.e±@7«+4Ç F#Ê×HÒ¼GÉ3'Íö-Õš›×Áo:È{¢±^ñÍ ’÷8Îm)j½Ž£<Ó ~èæÒ‰\õºþ›Ÿ+›S„–ëy>¿!C毄ç©V™uö7½hг-+Bf€tCŠeN’Ôs ÉŸöVf¡íÈ°Äz˜2Œ‘D·ÕÚ6O9šŽõñ»õåœ/ß]¹à=5øyïóg9bÖêý%²-Peð÷ËÐÉšºó`fOÁuÝwr»éoQ)¤ß “Qÿ ï2vE ?äåüB"‚Û¨c+Ù?‡÷6ØlůìNÒgrŠ^ž™woØ7]ŒøêtX5ÔíSŒW§Ì ‰3Mt§0Œ¥:Ûé—Pª
Úœ$ÚÖÇ^6„Ït…§yÂxG½_u¤Ú”éÒ8ƒ£tëÄ" Ç‚ÿpvÊí½Îhõ:öÃnûÃ{±Ý7¬YÜ#-çtEÙE]%¨¶
Ê‚ ’*ehY§—!¨—ùaknwƒäîS ~ðÌÊ€-þkÓ·cúS&%ÇEȱ•¦rì§fÿ7/üƒF‹õ¡ ó~ìO‹
Ç+Š¤s:9¾KL;÷ž¾æŸ
‡M&ØDrÇ®{y‹,ƒuÚZ÷ Õž nÕ‚œ ¼©#©VÕmb!
dZ~ú'«Á:GR©¦7V—Å{ï͆Å8¸ Ä Ë"Á9å¯!tRŒ Ÿ*˜z"›uk7Ì à<ôr½Œýð½ê_ò`
¦†ƒŸ—Ì¡Õêã ŸoN¸ÈŠ«¸ ƒ!Ò…;g¦B,´Í
íÔþ88Îj 5'Ø‚Ô¹¡ýµ6;3¹ñMÁÖ‹w@°`ÕVó°lcI™-V.W¿4oýÝ.´/¾‰¨ z&aÙ£DsrãÁ©–§£ ßêÇ„Spz¤=~TYwÅ]æB…ÞE 3B:ÖHwÊ]F]®ÄŸÞ
ÖÜ‘ÞVppr±ja縎F66:S M—
ñ†Ö«ih,ËÂä /ôí;¾º?43§Lñk-̨(® ^¾"ÜXC´½^W<Üž‘°Å[ÉôŽ:þ ~*‚ LüΦ Ú°Çr˜4Ò5þãuÇôW]-Á j¾¾ T0k–]å]73ÍÌÚwû% NSDð$F˜Ó8 ÙÆx©x¿#DeÑY ÇE€Zgæà&¶#Oåa˜†þt‰Ù ×]Í{ïñckµSdâ}Å4Ì eKyÈçËØ*FÍW•@'ü¯¼É}[DÇ8Î#!¿5æb¸-Jƒ”hAzw;ÿ*yD*>åýù”xËXŠV 3‹Ö‡ü N) ðg‚-*9G vÈ'u¨ƒxÊà (]Qä´Ùv%>§4úŠ–}>ÏÒgNø|H+4 •yƒUì E߬¸b8 )*÷¨Þô%u“q;2ÌS]¼ˆª õz+òi2Ž@þáœcz;ßEÂe!{ê{ŠŠµÖ+6¡@^æ÷ú‘P
p{Q¸·Ã”!
• ½5Eؽ{½løk…¹«:¶¼6‰HðÂÈ
àÞ±}Pëwã_óŒ^ïõ³¾ ›g‹u^~ 9qt9x¡Ó¤M¿™ËH!&ßMó¥÷Ñ©ÜÓ,âá°„‹óŸx¬~S¹ì,Y÷-y ]X“e˜† ˆ7Ïi¡Ðéƒ:Áq.;¬lP«BÏZÔ}€2Jö¾î„šÿÔ$-X 6ý…º óÙ£KSBó2œ¬x¢žÁÞÑÂ…Fí.¾+ ´¯
Ź_9f„C÷^ÄçFŒö²k…*¡ð%¿@ª¦4=ßžì3«Ücü=Ö¿z"ЬÄà¿ò`›4@˜À™¶¤Ž„íÆÈoÆö0Uý
;úÿJYº¹y…€ ÿ÷_ ] ¯ä#Êß×*n>ŽU…ш4R#Ó3 Žð ßúò™`ð@uÆÒê;Ìžr½TÕ¢(hÃÏ@®¦ì˜0„<ßיhâÕÀf?*þ#õ¼È\€ÒZí²µôIª}#”lŽL«ài|&môJ0ÉJe|w+³ úÅAîGS@ R1~m¥C†*ïÍK9•o^dÀ
ÝY1tÈ÷ à·Ë:KcÓ´™$m‘é\ùOãÄ
¼»1ÂKî&S¬†Ä”Éì5+Ï<ƒ
ª!É…lÜÂ3«D·0šŠ úäoÕ²WÊø¿ 'c¹Ø̾”ìí¢*¯þ˺ÄâðâjðºqhÑ¡_…Ü —=H·ô;ÕKÉ—Rš:D®p+ꚇôÓ¿._P>ÄiB8ž …E:p$¥h>öÓ”Ù:¾E ß [}½d…W
úëM;†ÍÒìùÒ„ÝrÙuÝþ(P5Ô ßfÄEU4Ü®¥9͵jZ Ïg í`œªlf4èŸï¶ÈZJ²ŽòúÅ•j.¤'WZo*Qø&Y½(&›Wø…qaU|åK‡šåºé{‰Ý²r³R&ŠBUÓ/<•8úò=N‘”Ú‚*šÐ/Nûë Íæ`Œ{u9bÞ²ƒÀŠv¯£(™¢£¤5yÈõRgÕóÖŠŠ–ȯ
‡f‚E®uFÊù÷È}2ú}ÎLÍ8æo£íjZ ‘Ðó2Ž3-³³‡™úböFô2cñh‹C%&s±êS‡óxZ6ô,=bÐ}(¿¢êj†£o‚:Ã2~sö(ŠéÈa„ãw2]Þìb; T—Ì•ï!N!wbL >•¥¬[B_)Ap ~•ÚÚùîïà#¤™$6f¦ýz˜|ÓÄñê#8æ j ÷û®aÒ¾cÙ:õÁb*=‘]1„÷¿:ŠG5—Á€²XK\s4.L îé&•Q…ÌúJŠ±üXðøÙ§Psw)óVøNS è6£ŠºÍþEâMéô‰ˆ‹£Üõ¬k¿Q
î—œ±J„¯—@‹cK
ùëU.ü¡Aý]D½*""ª.P=3aLyZ¢µÙ-ž˜-à `Ü¡Ý6÷m4 úòµÖ>øQ‹4€ K‹ô"Cè†ÝMrul·æg!êÖeËЂ;2r¥4x)~+\>W>÷¥¾ã‚ìù˜~›;•E7fÉHüþ}è0HM€ó-HÓº¼ŒªýžôSg®WH³ >¸QŸÆ ^/5Ôî{§ð[¦7ÔikÍðspsÙÄ¡Š›Ç0±¡®!Tq§m2õe"OýÈÑ–e#4³j ácíû2¸G
¹‡i0¶OWä
Ê|zœYÈÅe]",}Û$à-n›i5–™R¿“æ>Hî`Æ åzý.ýѼk0Â-KöRí‹q>Åñ¸@\íÿÓžr#ô3ÕxK*™Tßoô¾á|Ú_ýSp8ÜOëLNcúÏÈÈá]ñáåfÅROÂoJC
Ì]æL#ö+µwtù·t DïòSd"ÛFÀéɇOZÚ‘ö϶®ÒÁYIíw½ÏFƒ T(×ÇÄήòïWâj¢ÅuÆ++Íõ8¡ù
~²žEþ×à‘œ ÓÆäG>! Nsü±þúŽÒЫÿê šŒˆhÓhkÀè#u9wß¡øÄ Wù²F܆A7 y*¬ûºG=ø‘©òs½jÞÒ¯rÜcTø¬9·EüY8+šò`2{L#· FHUN£ú™é®urÒngùµ†®¯jD›Ðÿ~ÕEáª
Šë"ú|É|”εÕæ¶$?3wëáêÑÑoqô†ÜYêSã›G¾YàÙ -[ÀvÞÇÎ:ª €ÍTç1ðß
ê‹{r>1#X Šía^åùÏæ3ìË Òî ^m ‰ à /H,Œ‘çV Ö»»:œ²LcèΫ÷ÙÈVaÅpûÒµ_ØM. x›
Æû1Yfâj¥}ñLð
h#¬Ç‚ºî>¾ØØù]ºî§2¦Dm\
ÂUú\Ä™EZ#9ö õè?ÛmF»ñÜÏ|N DæUQ¥êí—€7*gT'q.õ!ÈÂ'î–Ò!óe¤¤RuóV'¹
=@7“¡‰2^¤,²»Ð#1Àýíé ;gÛ€Á Éä˜l"}[ðœR0Ë‘‡vé¿çB§) ¯.ý¹Œ™+áƪ!|IÁ—
³²b¦.?|»ÉŸ²}býÒQÒ/Š»Mš2ñ‡ŒšhèB¬'œf³\…
^+ûÆU’óšsBºùD I
\ÉÓðØåâP½(>Nïù:Ô|²
*¿ö".ud”ż›÷ =äúÙ‘T5{U /¤ÐTf¦ùÂ]f§‰ã¢®þ|y«}X€RG†u…x‚oùq¼
ÞÅœ,ˆl
d…jåÇ®¶«‰uPDÖl`E–ìˆ8[XòÌLm{ú O¸?8*r@©×ið§ B3âò±ì^ù±
¥Â¢Ó“Y]à’+Ü©´*böD$>E=›æ ºµ¨¼ÂÏ°ÂÁC.~žÓ>8
rŠ÷=‘W©c%ä~ÆÁHâ:½0OÇ òàêfµnßf †îÕTçêé¶ç
Än—5ñbÚšÇ;>¼M>ÙÐÉ~gá-ÒS:™Üý…&‰å;8 ¢Pþ»¼Z+N~©õdÓL#€?#xXéc ¾ïöu4ÄNm•ÂÙŽ¤›± ¦=ð4اÔĬºà qtÃ{Öˆ~ +€D¢Wx§"µ@DcC¬ÍÃZ £VŒK‰M¢i¶Ð3RNGkÕû8›1Ûöȹú⥰ä/ÎHwn« &_Ío— ÔK)1 ¥´<éœÑ
ºX3îÈÒÜ‹òFŸRg¯wÂ`c†â}§ƒÂ¬Ô à†zBû¾ãªLl|‰GÊ|à*_ õmMê[ÆÃeÏV&ÔÖç YÚO°©#žÖÄl ¯ÒÿQrç0 ‡ ïSH\ ºÊÔî¡•<Œ ïØýKiCyµµ$üßÑ ÄPR*8Xß;
n â€sú¿ Ùß´?ÏÍÍ¿6ÚÏÂéœÒG 1¨»E®$
É2 ^S÷ƒcéà,v,R¯ÉF7"ñ´«ÍyE&÷^é0ûHù WõÉ¥©;+b¶uæ2˜ó*‹§†ÿ¾$jô:
.h-{Q/¶[ž””Z`/a0ö¯iû«á·pOaZ)•^É|RÑÆ$c»¾® ï 9/ îýK”fË·ÑYsŸ£ÐŸÞ~qæî1,ÿòúÊ }bÊY¡gÅU`éݯK±f°gùgf ÇC/©[ö¦da#-…bT
eG&é² _W?„È g.‡è³Ó6írw&˜[ÿ~ Å´jŽ<Ηʛ tèª:ÂßÝy¦¼º3 ”„&…kÙ`D§€÷—¾û
,¸â~byÝãýí¡
*'`m ¹þD1.^qþ2‚äøõE¿tsûÍ_ZLŠ{ ÿhÿ¡2Ñá¤Ç´5Ãþ܅¢7B ‰ ´gV&Ìèµ×%&WÞX#BÛêÔÓ>û©“
—zÈ8öJGê q”|¡^üò'w*([ù(*1§©—•ÓpŒn›…g8úWÈ6ªZ=²£*w‰XŠ"Ü“e–#iö+AF÷ÉëaèÒì†DÔZ–;ÏT >`[EO‘ ÐÀj¦ƒãèÌ*ß1ØŽú£ãÆM.$Þ¢ó+@!TÕ^; `ų÷6›{ˆKE[ù½Ðû$l©I~=ÕW<Ó/ð…ö¡y^§g'}îörüÎЈp="qk|פËgè攣’Š\»ç”ŽÄ€:éʃ['®VÝCx®×ƒ =~s=]É
a T|Ù-oSs[6ú<̺ œQê}£‡Ÿ{íëùÐÍò`óSúÚp
c~éjHÄ~LHSñËQXH ‘¯DrŽ%,³ãPNåWҔߖwÃIêãª0Ëœ»8‘6Ÿse‚ÇzÿÞîô\;àßDôW…êësóxÛ‚Òy‰õpéÿÍE¡Ãß{°Ž&Ÿ"ðÛx‹Dycc˜µù$tcÓ–cŒ |»vw9ê:1FÚ–S:ìj J ïÎîµ Kþ¸ph¿)7Õn£uÁ:L£/(~Æ[‡'mVº£ë‡•HS^0ËpÄáÔ$Úïéz ÔìÉyß,~ÒœJ÷û.›êô/º.—ß4Æ°CÎn†íUû1°x»€¥ 9=à÷G!ŸÄ tÅó ’÷_ËpG·Ü–tȆc êC
yÙǶ¹„úTèÀ7MFÚon÷œ²ˆ¶¸FJâ@a[…bïÈö4égN
gVÎÇWˆJx
⛃!èô$cÿÑ‹”ž¯c¼öõö¤y±òQxÂHþ
¯kKÞ"p½
à ×Ä-Bþõ”»n¦oëâgjÚŒô¸a˜(…´F՘ͲIÑàɯ*÷J„ëšY¥–éoÑ Gܸ¿‘LLE%ç%3Ûa/eg¹–suu8Jµ d‹CÍÔc±Rˆ·R××Á&¬¤A*Ò7@€éÂí|W¹«Eî-p¥Ë ìù Ò†4¯ÔÇܖ4]T÷³PÖÛ®'×éS{Id½ a ¯:Ss¸_X{MA^ÜhcßPƒ¢û^–j! fꉫaŒx«‚igh|œ·`žÌa¬€‰@œä¨gY»Áí
k£šnaµ†[©–„¾3òÌFÃENʳ =Ø‚>®´ëZ`ûû†|oRæD…ÓØÛ[ÔôgN§NÀ£È¼ÏçQTC@„óÙx¸áùƨFO¤é¦hãW¥0T/œõ°;<–B0µäõ¼ª¶j_±c˜W¹ ^+Ò:NýE¶á°¬±}€Ú ¬jXrâ˜9÷?I¼AyÙŸ½˜¾–qòÉÂfË K–‹?¦Äª§BÛ©]” ¨ÐË€l9ä!Váãï(ðº-y=ƒ¬¤ ¤ ÷dŠ<©™; Uõ<›£9«ÂE·Eza™¨¬ªÀGwz\èaRG!vj_ÞΛãϘw`a{ î Œž ïéCÇbpèÏxÅÓXlTæ8ÏLdÒYDÍš`;Å_æA=³‡M=¼*“TÈ
”Ä°µ§êf9’={h¬•íèLJWÙ?¼äÌësÛË¿ÑÛÉHÖcV‹‰º1
ù@mv_i¶ª1ä›÷ÛùgØj>t˜]šÄZ™«_‹ÜfïYÇÓù:g +ôIh}þÞäVÒ L)ùFß—?*Bb;ҼȽœ í,ªøª Rßx”ÓûÒҹȩS`$(H ¦Ú\9+ÂÐMXÎöØ{ïòm‘% ëD ”é”b Þ-‡‘¼š1™5óá’Y–ó,„™ŠÅF56±ä)PòÍE
•õ×Ô|]qƒL7Úé"¬"‚;“}éI3‹2¨s‚nÁÊòÜìÏn
¢®÷ïXß1ßÎ ºŸE/¿¯……÷/
p8GÜÕ ñ†0A xøäœLmÓ‹G—#üÔOvUJâÂ)ù%×Á„µžÊø
ïÛgÈÙÎ þ#ûÌ‹àëÇ{Hã:;ö'9â/*ššpÊižs«”ÁÊ\Ér–l÷jÊkµ£¤‹_Qí_a`ãmá3œèÛÐ yªº0ce–Î"ÒŸ°_{C;Rg!°ŽÞ <]y‘Ö9áíÀk£ ÈÉ©ï”™ÔÍÊÃÉ»H@ø3ÞÖlÕ0õ%É™ K¹Vrr#/r˜¬ä@ÝcÖñfR ”©Ã¦*’%HG¸Ù9o5üÚ&£uµKס´ïÎê«œiƒŽÏl©8!‡kp6k¯Ÿ|¡¯ñEøM.>,ßþ>ª&s •9Cûn¬ìŒù™BlÜÙ*ˆsTz‚YÆPI«îÿÞ =4Ÿ¼£fÁ÷Ä.¸ý–êuéâ–W÷„•2ô°óÖ)!¶’+9N\†Õ÷ìv°›Ö ¾¼õvA
3|cŸ¦"ïîŽä;bÉNÀkå:šáB¾‘ÖœÃ}bÝýÂDà×àzXømþŽL;zçü°ñwC ¼|Ün»ýÛLiW1‚„Öš¤Ô‡ç#r3ËccP!„٤ ÀÙBim¥´n%of‰S›bñp±ŒØT$Ê ˜ CèÌp
íN«ðúÒ~Áý6ýÞø=ÓAíRvªu†º(aÆã£vMö¼{±àUs0£ í :úž„zÓQÌÊò9¯ Câã!¦¡³•GewÝþ‡Ó;÷¶ôBs;Aq {°ÚëÂÜ8±“'
Qxýˆ>7 ÞhŸ#ÀO¿, KEó€DÐõÌ㺛Ï`!à¡Ë]}A
Š)çjÓéÎlã ªg!5Æ× ‰Ó\÷nâ-±ÎQ3`PÐê<¥'FQ³×<“ýolÑpsR«¯æöZQ–Ð0×A³'Á2ŸÈÛÉ‹8Œ,ö÷ªÚ\§ ³yùE<5øý?ìâö"Z äù“qöGàÿ¿¦ÔðPöòŽ:¦ ñ [U^»å¡tyÑ}²ö…¯cבLê²åî»`Ãíôxf–!PSVürÇ7ž¾Á0ºÓÚ .¤ã‹w2^k¨ÛÏî§U¶µ—ÑìÁû¯Y+ Ã…ö/çxj ‰Æó_Ênµ)©å-,V²9éåÛgc[6 -éQÓmR©Dry¬¬siŠóÁc)Ð%YºÖ6ýïNc¤¹ÖéªÏCXzïn°Q¿Ë¥½€1² ò&ðtê¿Jz7™&³ˆt÷³9K± ðÙªOyµR‡M$»iîBˆAôOEêZy®çqRï“P¡«Ð0¨)añÄÜÅWi‘Í°*7Ü¡ìø){(&,)—‘¥,9>O¶,½/|àn÷[
Äš_ ýk ËŸ3†cÇ¢’·mz1ÄO¹HýžÍó·lƒìøØÙ ~E
9½4.ÛPB û[Ñá÷‡Ã%5ûÜyF@å^aNø' õëå¹9s{a«bL Ä÷C„Ë\– ƒ“ñ;
Iª²›ß5¼rù_JøX(¹çÓ^ƒÀΆ‹jbàä_’Ó^ïX+¬‡^ÛOÌB3 5Í9’æzå3Œ(ÿ^]UC'Ng©ÅÑ0†m›gÂj-üd{b"¾·erƒÕsüÔwGù¼ù›´ŸgüqDO𖚉´ë—ʱ4Þ?™Ê– !©×5ÍôÇf"fcKaL¿¿^€@À2{}Ç%®AŽSc¬ö—@ù ´m‰#³ë! Úá¼óÇ,’ \
#5a½¥æ¤€Â´©µ×¢{¬³½ÿ‹ÕŒóô)”'ójœ^ ñ¹ä¤”%ÄMCÿPKãæǾU; Y< PK
>C / Haxe Toolkit Installer Template/neko-2.0.0-osx/UX ‚IRkIRõ PK >C 8 Haxe Toolkit Installer Template/neko-2.0.0-osx/.DS_StoreUX ‚IR’IRõ í˜;Â0Dg K4.)Ýp n`EÉ ¸ W ÷Ñ!Ú²RP%‚y’õVŠi O Øð¸_€ Á3>’Ø„®6Î!„Bˆ}c®tÜvBˆ 2Ÿ…®tsŸ:vc2]èJ7·±_ #èLºÒÍÍCË>Œ+Š1…X¡ëW¯,Äßppåùû?a5ÿ !~‹ãu ð˯vëê†õK@🅧nl¡+Ýܺ±OPKj ˆm² PK
>C 8 __MACOSX/Haxe Toolkit Installer Template/neko-2.0.0-osx/UX ™IR™IRõ PK >C C __MACOSX/Haxe Toolkit Installer Template/neko-2.0.0-osx/._.DS_StoreUX ‚IR’IRõ c`cg`b`ðMLVðVˆP€'±ƒøA L… V PK¾CŠ * R PK >C 9 __MACOSX/Haxe Toolkit Installer Template/._neko-2.0.0-osxUX ‚IRkIRõ c`cg`b`ðMLVðVˆP€'ñ ñï1 CB‚ LŽ@솦„!.šœŸ«—XP“ªWXšX”˜W’™—ÊP¨o```hmj˜h``l”f힟Ÿž“SadàœQ”Ÿ›jíh`blbnéªkjääªkbaâªkélä¨ëâìldäèdâdädÌ PK#"ü¿‘ Þ PK
>C $ Haxe Toolkit Installer Template/out/UX ‚IR’IRõ PK >C - Haxe Toolkit Installer Template/out/.DS_StoreUX ‚IR“IRõ í˜;Â0Dg K4.)Ýp n`EÉ ¸ W ÷Ñ!Ú²RP%‚y’õVŠi O Øð¸_€ Á3>’Ø„®6Î!„Bˆ}c®tÜvBˆ 2Ÿ…®tsŸ:vc2]èJ7·±_ #èLºÒÍÍCË>Œ+Š1…X¡ëW¯,Äßppåùû?a5ÿ !~‹ãu ð˯vëê†õK@🅧nl¡+Ýܺ±OPKj ˆm² PK
>C - __MACOSX/Haxe Toolkit Installer Template/out/UX ™IR™IRõ PK >C 8 __MACOSX/Haxe Toolkit Installer Template/out/._.DS_StoreUX ‚IR“IRõ c`cg`b`ðMLVðVˆP€'±ƒøA L… V PK¾CŠ * R PK
Ö>C ( Haxe Toolkit Installer Template/scripts/UX ‚IR$IRõ PK Ö>C ; Haxe Toolkit Installer Template/scripts/haxe-postinstall.shUX ‚IR$IRõ }O»
B1 ÝóÇë&”Ž ü WqðöA m/´Wñó
uÒP—óÈIr<è5UÝ#µýèmÀxyA¸Í
.§•r…ê šá Gù‰›Ù8Vî™™ÈRÀÊaùös³àvÆ }% C 1 __MACOSX/Haxe Toolkit Installer Template/scripts/UX ™IR™IRõ PK Ö>C F __MACOSX/Haxe Toolkit Installer Template/scripts/._haxe-postinstall.shUX ‚IR$IRõ c`cg`b`ðMLVðVˆP€'q%ƒø«ˆŽ!!AP&HÇ æGSˆOÎÏÕK,(ÈIÕ I(qÍKÎOÉÌKJ––¤éZX›š[Z˜ PKpÀ] « PK q>C : Haxe Toolkit Installer Template/scripts/haxe-preinstall.shUX ‚IR†IRõ SVÔOÊÌÓ/Îà*ÊUÐ-JSÐ/-.ÒÏÉLÒÏH¬HÕ/.IÁ.‘’Ÿ PK4’Žp) ; PK q>C E __MACOSX/Haxe Toolkit Installer Template/scripts/._haxe-preinstall.shUX ‚IR†IRõ c`cg`b`ðMLVðVˆP€'q%ƒø«ˆŽ!!AP&HÇ æGSˆOÎÏÕK,(ÈIÕ I(qÍKÎOÉÌKJ––¤éZX›š[Z˜ PKpÀ] « PK ܹB ; Haxe Toolkit Installer Template/scripts/neko-postinstall.shUX ‚IR04 Qõ SVÔOÊÌÓ/Îà*ÊUÐ/-.sóR³ó1’1Drs0„JòósŠá¢9™I ’ÐK©²¸¸ròt‹² )0f9.eÉènÂ¥07ø”‚ÝŒÍØ4 x‡/PK‹´ÓJ\ U PK ܹB F __MACOSX/Haxe Toolkit Installer Template/scripts/._neko-postinstall.shUX ‚IR04 Qõ c`cg`b`ðMLVðVˆP€'q%ƒø«ˆŽ!!AP&HÇ æGSˆOÎÏÕK,(ÈIÕ I(qÍKÎOÉÌKJ––¤éZX›š[Z˜ PKpÀ] « PK ì¸B : Haxe Toolkit Installer Template/scripts/neko-preinstall.shUX ‚IRí Qõ SVÔOÊÌÓ/Îà*ÊUÐ-JSÐ/-.ÒÏÉLÒÏKÍÎç PK%=p×! PK
>C @íA Haxe Toolkit Installer Template/UX ‚IRaIRPK >Cdè 0 ) @¤N Haxe Toolkit Installer Template/.DS_StoreUX ‚IRaIRPK
>C @ýAÕ __MACOSX/UX ™IR™IRPK
>C ) @ýA __MACOSX/Haxe Toolkit Installer Template/UX ™IR™IRPK >C¾CŠ * R 4 @¤c __MACOSX/Haxe Toolkit Installer Template/._.DS_StoreUX ‚IRaIRPK
Y:C = @íAÿ Haxe Toolkit Installer Template/Haxe Toolkit Installer.pmdoc/UX ™IRYÉCRPK Y:C8šŽš÷C '½ P @¤j Haxe Toolkit Installer Template/Haxe Toolkit Installer.pmdoc/01haxe-contents.xmlUX ‚IRYÉCRPK Y:C õ;ÿì † G @¤ïH Haxe Toolkit Installer Template/Haxe Toolkit Installer.pmdoc/01haxe.xmlUX ‚IRYÉCRPK Y:CŠ/ î P @¤`K Haxe Toolkit Installer Template/Haxe Toolkit Installer.pmdoc/02neko-contents.xmlUX ‚IRYÉCRPK Y:C™§Ò•Û P G @¤ M Haxe Toolkit Installer Template/Haxe Toolkit Installer.pmdoc/02neko.xmlUX ‚IRYÉCRPK Y:C"›gyñ œ F @¤}O Haxe Toolkit Installer Template/Haxe Toolkit Installer.pmdoc/index.xmlUX ‚IRYÉCRPK Y:C%í!Ÿ( R G @¤òR __MACOSX/Haxe Toolkit Installer Template/._Haxe Toolkit Installer.pmdocUX ™IRYÉCRPK
>C / @íAŸS Haxe Toolkit Installer Template/haxe-3.0.0-osx/UX ‚IRgIRPK >C§N¼ 8 @¤üS Haxe Toolkit Installer Template/haxe-3.0.0-osx/.DS_StoreUX ‚IRjIRPK
>C 8 @ýAŽU __MACOSX/Haxe Toolkit Installer Template/haxe-3.0.0-osx/UX ™IR™IRPK >C¾CŠ * R C @¤ôU __MACOSX/Haxe Toolkit Installer Template/haxe-3.0.0-osx/._.DS_StoreUX ‚IRjIRPK
j>C : @íAŸV Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/UX ‚IR˜
IRPK
ú>C I @íAW Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/UX ‚IRÈ IRPK ú>C€Ãþ
Q @¤~W Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/.currentUX ‚IRÈ IRPK
ú>C T @íAX Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/UX ‚IRÈ IRPK ú>CȈuÒé f ` @¤›X Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/haxelib.jsonUX ™IRÈ IRPK
ú>C Z @íA"Z Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/UX ‚IRÈ IRPK
ú>C b @íAªZ Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/UX ‚IRÈ IRPK ú>C|Ñ øÅ é o @¤:[ Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/ConvertXml.hxUX ‚IRÈ IRPK ú>C?ÖA% { i @¤¬^ Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Data.hxUX ‚IRÈ IRPK ú>Cü‰{F c w @¤xj Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/dbconfig.json.exampleUX ‚IRÈ IRPK ú>C¼šu˜ Ð
m @¤sk Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/haxelib.cssUX ‚IRÈ IRPK ú>CDhŸê¾) … i @¤¶o Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Main.hxUX ‚IRÈ IRPK ú>C–š÷Ú ö j @¤š Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Paths.hxUX ‚IRÈ IRPK ú>C¯, í — l @¤Ñ› Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Rebuild.hxUX ‚IRÈ IRPK ú>Cð§Ù…š Ó$ i @¤hž Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Repo.hxUX ‚IRÈ IRPK ú>C•^ØY k @¤©« Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/SemVer.hxUX ‚IRÈ IRPK ú>CÛ±'h‚
Ç# i @¤«® Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Site.hxUX ‚IRÈ IRPK ú>C#‡i‰‘ \ l @¤Ô¼ Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/SiteApi.hxUX ‚IRÈ IRPK ú>C™5 Y : k @¤Á Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/SiteDb.hxUX ‚IRÈ IRPK ú>C¥!Ð0Á m @¤É Haxe Toolkit Installer Template/haxe-3.0.0-osx/lib-client/haxelib_client/3,1,0-rc,3/tools/haxelib/Template.hxUX ‚IRÈ IRPK v¹B1ÏÕ“. d2 , @¤}Ì Haxe Toolkit Installer Template/haxelogo.pngUX ™IR/7 QPK l¹BãæǾU; Y< - @¤zû Haxe Toolkit Installer Template/haxelogo3.pngUX ™IR7 QPK
>C / @íA:7 Haxe Toolkit Installer Template/neko-2.0.0-osx/UX ‚IRkIRPK >Cj ˆm² 8 @¤—7 Haxe Toolkit Installer Template/neko-2.0.0-osx/.DS_StoreUX ‚IR’IRPK
>C 8 @ýA¿8 __MACOSX/Haxe Toolkit Installer Template/neko-2.0.0-osx/UX ™IR™IRPK >C¾CŠ * R C @¤%9 __MACOSX/Haxe Toolkit Installer Template/neko-2.0.0-osx/._.DS_StoreUX ‚IR’IRPK >C#"ü¿‘ Þ 9 @¤Ð9 __MACOSX/Haxe Toolkit Installer Template/._neko-2.0.0-osxUX ‚IRkIRPK
>C $ @íAØ: Haxe Toolkit Installer Template/out/UX ‚IR’IRPK >Cj ˆm² - @¤*; Haxe Toolkit Installer Template/out/.DS_StoreUX ‚IR“IRPK
>C - @ýAG< __MACOSX/Haxe Toolkit Installer Template/out/UX ™IR™IRPK >C¾CŠ * R 8 @¤¢< __MACOSX/Haxe Toolkit Installer Template/out/._.DS_StoreUX ‚IR“IRPK
Ö>C ( @íAB= Haxe Toolkit Installer Template/scripts/UX ‚IR$IRPK Ö>C ¤*c‡ ” ; @ÿ˜= Haxe Toolkit Installer Template/scripts/haxe-postinstall.shUX ‚IR$IRPK
>C 1 @ýA˜> __MACOSX/Haxe Toolkit Installer Template/scripts/UX ™IR™IRPK Ö>CpÀ] « F @¶÷> __MACOSX/Haxe Toolkit Installer Template/scripts/._haxe-postinstall.shUX ‚IR$IRPK q>C4’Žp) ; : @ÿØ? Haxe Toolkit Installer Template/scripts/haxe-preinstall.shUX ‚IR†IRPK q>CpÀ] « E @¶y@ __MACOSX/Haxe Toolkit Installer Template/scripts/._haxe-preinstall.shUX ‚IR†IRPK ܹB‹´ÓJ\ U ; @ÿYA Haxe Toolkit Installer Template/scripts/neko-postinstall.shUX ‚IR04 QPK ܹBpÀ] « F @¶.B __MACOSX/Haxe Toolkit Installer Template/scripts/._neko-postinstall.shUX ‚IR04 QPK ì¸B%=p×! : @ÿC Haxe Toolkit Installer Template/scripts/neko-preinstall.shUX ‚IRí QPK 8 8 7 ¨C haxe_3.2.1+dfsg.orig/extra/release-checklist.txt 0000664 0001750 0001750 00000002023 12607337712 021574 0 ustar andy andy 0000000 0000000 # Preparing related projects
- Check that haxelib is working
- Make sure to update the haxelib submodule
- Check that the run-time haxelibs are ready for release: hxcpp, hxjava, hxcs
# Building the binaries and installers
- Make sure CHANGES.txt has a proper date set!
- Make sure `version` in main.ml has the correct value.
- Merge development branch into master.
- Wait for Travis to greenlight master.
- Tag master as MAJOR.MINOR.PATCH.
- Wait for builds.haxe.org to build master.
- Get https://github.com/waneck/hxbuilds/tree/master/release-helper
- Run it with the fileName corresponding to the latest master file name on builds.haxe.org.
# Making the release
- Push the generated binaries and installers to haxe.org.
- Copy relevant changelog part to CHANGES.md.
- Write announcement post.
- Copy announcement post to RELEASE.md.
- Update versions.json
# Announcing the release
- Update Github README page.
- Regenerate and upload API documentation.
- Update http://haxe.org/file/CHANGES.txt
- Post announcement post to haxelang.
haxe_3.2.1+dfsg.orig/extra/release.neko 0000664 0001750 0001750 00000004134 12607337712 017747 0 ustar andy andy 0000000 0000000 version = $loader.args[0];
if( version == null )
$throw(" argument required");
sys = $loader.loadprim("std@sys_string",0)();
binext = "";
curdir = "./";
ext = switch( sys ) {
"Windows" => {
curdir = ".\\";
binext = ".exe";
"-win"
}
"Mac" => "-osx"
"Linux" => "-linux"
"BSD" => "-bsd"
default => $throw("Unknown system")
}
rights = 493; // octal 755
_mkdir = $loader.loadprim("std@sys_create_dir",2);
mkdir = function(d) {
_mkdir(d,rights);
}
chdir = $loader.loadprim("std@set_cwd",1);
_cmd = $loader.loadprim("std@sys_command",1);
cmd = function(c) {
if( _cmd(c) != 0 ) $throw("Command '"+c+"' failed");
}
dir = "haxe-"+version+ext;
cmd("rm -rf "+dir);
mkdir(dir);
mkdir(dir+"/doc");
if( sys == "Windows" ) {
cmd("cp ../haxe.exe ../haxesetup.exe haxeserver.bat "+dir);
// copy if available (means we build on recent OCaml/MSVC)
try cmd("cp C:/Windows/System32/msvcr100.dll "+dir) catch e {};
} else
cmd("cp ../haxe "+dir);
cmd("cp -pR CHANGES.txt LICENSE.txt ../std "+dir);
if( sys == "Windows" ) cmd("chmod -R 777 "+dir);
cmd("haxe all.hxml");
chdir(dir+"/std/tools");
// BUILD TOOLS
chdir("haxedoc");
cmd("haxe haxedoc.hxml");
cmd(curdir+"haxedoc -v \"../../../../neko.xml;neko\" \"../../../../js.xml;js\" \"../../../../flash9.xml;flash\" \"../../../../php.xml;php\" \"../../../../cpp.xml;cpp\"");
cmd("mv index.html content ../../../doc");
cmd("mv haxedoc"+binext+" ../../..");
chdir("..");
chdir("haxelib");
cmd("haxe haxelib.hxml");
cmd("mv haxelib"+binext+" ../../..");
chdir("..");
// CLEANUP
chdir("..");
cmd("rm -rf .svn */.svn */*/.svn */*/*/.svn */*/*/*/.svn");
cmd("rm -rf all.n all.js *.swf *.xml");
chdir("tools");
chdir("haxedoc");
cmd("rm -rf haxedoc.n index.html content haxedoc"+binext);
chdir("..");
chdir("haxelib");
cmd("rm -rf *.bat *.zip *.db *.n tmp files");
chdir("..");
chdir("hxinst");
cmd("rm -rf *.n *.zip *.dmg *.app hxinst-win.exe hxinst-linux hxinst-osx");
chdir("..");
chdir("..");
cmd("rm -rf mt mtwin");
chdir("../..");
// PACKAGE
if( sys == "Windows" )
cmd("7z a -tzip "+dir+".zip "+dir);
else
cmd("tar -czf "+dir+".tar.gz "+dir);
cmd("rm -rf "+dir);
haxe_3.2.1+dfsg.orig/extra/setup.cpp 0000664 0001750 0001750 00000005062 12607337712 017316 0 ustar andy andy 0000000 0000000 /*
* Haxe Setup
* Copyright (c)2006 Nicolas Cannasse
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
// this is a small program that do basic Haxe setup on Windows
#include
static void Set( HKEY k, const char *name, DWORD t, const char *data ) {
RegSetValueEx(k,name,0,t,(const BYTE*)data,(DWORD)strlen(data)+1);
}
int WINAPI WinMain( HINSTANCE inst, HINSTANCE prev, LPSTR lpCmdLine, int nCmdShow ) {
char path[MAX_PATH];
*path = '"';
GetModuleFileName(NULL,path+1,MAX_PATH);
// register .hxml extension
char *s = strrchr(path,'\\') + 1;
strcpy(s,"haxe.exe\" -prompt \"%1\"");
HKEY k;
RegCreateKey(HKEY_CLASSES_ROOT,".hxml\\shell\\Compile\\command",&k);
RegSetValueEx(k,NULL,0,REG_SZ,(const BYTE*)path,(DWORD)(strlen(path)+1));
*s = 0;
// add %HAXEPATH% to PATH and set HAXEPATH to current path
DWORD ktype;
DWORD ksize = 16000;
char *kdata = new char[16000];
memset(kdata,0,ksize);
RegOpenKey(HKEY_LOCAL_MACHINE,"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment",&k);
RegQueryValueEx(k,"PATH",NULL,&ktype,(LPBYTE)kdata,&ksize);
if( strstr(kdata,"%HAXEPATH%") == NULL ) {
char *s = kdata + strlen(kdata);
strcpy(s,";%HAXEPATH%");
Set(k,"PATH",REG_EXPAND_SZ,kdata);
}
if( strstr(kdata,"%NEKO_INSTPATH%") == NULL ) {
char *s = kdata + strlen(kdata);
strcpy(s,";%NEKO_INSTPATH%");
Set(k,"PATH",REG_EXPAND_SZ,kdata);
}
Set(k,"HAXEPATH",REG_SZ,path + 1);
s[-1] = 0;
strcpy(strrchr(path,'\\'),"\\neko");
Set(k,"NEKO_INSTPATH",REG_SZ,path+1);
RegCloseKey(k);
// inform running apps of env changes (W2K/NT systems only ?)
DWORD unused;
SendMessageTimeout(HWND_BROADCAST,WM_SETTINGCHANGE, 0, (LPARAM)"Environment", SMTO_ABORTIFHUNG, 5000, &unused );
// delete kdata;
// // register
// if( strcmp(lpCmdLine,"-silent") != 0 )
// MessageBox(NULL,"Setup completed, you can start using Haxe now","haxesetup",MB_OK | MB_ICONINFORMATION);
return 0;
}
haxe_3.2.1+dfsg.orig/extra/setup.sln 0000664 0001750 0001750 00000001556 12607337712 017334 0 ustar andy andy 0000000 0000000 Microsoft Visual Studio Solution File, Format Version 8.00
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "setup", "setup.vcproj", "{6E869222-35FF-4BC0-B5AA-E63BCB8803A6}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfiguration) = preSolution
Debug = Debug
Release = Release
EndGlobalSection
GlobalSection(ProjectConfiguration) = postSolution
{6E869222-35FF-4BC0-B5AA-E63BCB8803A6}.Debug.ActiveCfg = Debug|Win32
{6E869222-35FF-4BC0-B5AA-E63BCB8803A6}.Debug.Build.0 = Debug|Win32
{6E869222-35FF-4BC0-B5AA-E63BCB8803A6}.Release.ActiveCfg = Release|Win32
{6E869222-35FF-4BC0-B5AA-E63BCB8803A6}.Release.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection
GlobalSection(ExtensibilityAddIns) = postSolution
EndGlobalSection
EndGlobal
haxe_3.2.1+dfsg.orig/extra/setup.vcproj 0000664 0001750 0001750 00000005476 12607337712 020050 0 ustar andy andy 0000000 0000000
haxe_3.2.1+dfsg.orig/filters.ml 0000664 0001750 0001750 00000112033 12607337712 016326 0 ustar andy andy 0000000 0000000 open Ast
open Common
open Type
open Typecore
(* PASS 1 begin *)
let rec verify_ast e = match e.eexpr with
| TField(_) ->
()
| TTypeExpr(TClassDecl {cl_kind = KAbstractImpl a}) when not (Meta.has Meta.RuntimeValue a.a_meta) ->
error "Cannot use abstract as value" e.epos
| _ ->
Type.iter verify_ast e
(*
Wraps implicit blocks in TIf, TFor, TWhile, TFunction and TTry with real ones
*)
let rec blockify_ast e =
match e.eexpr with
| TIf(e1,e2,eo) ->
{e with eexpr = TIf(blockify_ast e1,mk_block (blockify_ast e2),match eo with None -> None | Some e -> Some (mk_block (blockify_ast e)))}
| TFor(v,e1,e2) ->
{e with eexpr = TFor(v,blockify_ast e1,mk_block (blockify_ast e2))}
| TWhile(e1,e2,flag) ->
{e with eexpr = TWhile(blockify_ast e1,mk_block (blockify_ast e2),flag)}
| TFunction tf ->
{e with eexpr = TFunction {tf with tf_expr = mk_block (blockify_ast tf.tf_expr)}}
| TTry(e1,cl) ->
{e with eexpr = TTry(mk_block (blockify_ast e1),List.map (fun (v,e) -> v,mk_block (blockify_ast e)) cl)}
| TSwitch(e1,cases,def) ->
let e1 = blockify_ast e1 in
let cases = List.map (fun (el,e) ->
el,mk_block (blockify_ast e)
) cases in
let def = match def with None -> None | Some e -> Some (mk_block (blockify_ast e)) in
{e with eexpr = TSwitch(e1,cases,def)}
| _ ->
Type.map_expr blockify_ast e
(*
Pushes complex right-hand side expression inwards.
return { exprs; value; } -> { exprs; return value; }
x = { exprs; value; } -> { exprs; x = value; }
var x = { exprs; value; } -> { var x; exprs; x = value; }
*)
let promote_complex_rhs com e =
let rec is_complex e = match e.eexpr with
| TBlock _ | TSwitch _ | TIf _ | TTry _ | TCast(_,Some _) -> true
| TBinop(_,e1,e2) -> is_complex e1 || is_complex e2
| TParenthesis e | TMeta(_,e) | TCast(e, None) | TField(e,_) -> is_complex e
| _ -> false
in
let rec loop f e = match e.eexpr with
| TBlock(el) ->
begin match List.rev el with
| elast :: el -> {e with eexpr = TBlock(block (List.rev ((loop f elast) :: el)))}
| [] -> e
end
| TSwitch(es,cases,edef) ->
{e with eexpr = TSwitch(es,List.map (fun (el,e) -> List.map find el,loop f e) cases,match edef with None -> None | Some e -> Some (loop f e)); }
| TIf(eif,ethen,eelse) ->
{e with eexpr = TIf(find eif, loop f ethen, match eelse with None -> None | Some e -> Some (loop f e)); }
| TTry(e1,el) ->
{e with eexpr = TTry(loop f e1, List.map (fun (el,e) -> el,loop f e) el); }
| TParenthesis e1 when not (Common.defined com Define.As3) ->
{e with eexpr = TParenthesis(loop f e1)}
| TMeta(m,e1) ->
{ e with eexpr = TMeta(m,loop f e1)}
| TReturn _ | TThrow _ ->
find e
| TContinue | TBreak ->
e
| _ ->
f (find e)
and block el =
let r = ref [] in
List.iter (fun e ->
match e.eexpr with
| TVar(v,eo) ->
begin match eo with
| Some e when is_complex e ->
let e = find e in
r := (loop (fun e -> mk (TBinop(OpAssign,mk (TLocal v) v.v_type e.epos,e)) v.v_type e.epos) e)
:: ((mk (TVar (v,None)) com.basic.tvoid e.epos))
:: !r
| Some e ->
r := (mk (TVar (v,Some (find e))) com.basic.tvoid e.epos) :: !r
| None -> r := (mk (TVar (v,None)) com.basic.tvoid e.epos) :: !r
end
| TReturn (Some e1) when (match follow e1.etype with TAbstract({a_path=[],"Void"},_) -> true | _ -> false) ->
r := ({e with eexpr = TReturn None}) :: e1 :: !r
| _ -> r := (find e) :: !r
) el;
List.rev !r
and find e = match e.eexpr with
| TReturn (Some e1) -> loop (fun er -> {e with eexpr = TReturn (Some er)}) e1
| TBinop(OpAssign | OpAssignOp _ as op, ({eexpr = TLocal _ | TField _ | TArray _} as e1), e2) -> loop (fun er -> {e with eexpr = TBinop(op, e1, er)}) e2
| TBlock(el) -> {e with eexpr = TBlock (block el)}
| _ -> Type.map_expr find e
in
find e
(* Adds final returns to functions as required by some platforms *)
let rec add_final_return e =
let rec loop e t =
let def_return p =
let c = (match follow t with
| TAbstract ({ a_path = [],"Int" },_) -> TInt 0l
| TAbstract ({ a_path = [],"Float" },_) -> TFloat "0."
| TAbstract ({ a_path = [],"Bool" },_) -> TBool false
| _ -> TNull
) in
{ eexpr = TReturn (Some { eexpr = TConst c; epos = p; etype = t }); etype = t; epos = p }
in
match e.eexpr with
| TBlock el ->
(match List.rev el with
| [] -> e
| elast :: el ->
match loop elast t with
| { eexpr = TBlock el2 } -> { e with eexpr = TBlock ((List.rev el) @ el2) }
| elast -> { e with eexpr = TBlock (List.rev (elast :: el)) })
| TReturn _ ->
e
| _ ->
{ e with eexpr = TBlock [e;def_return e.epos] }
in
let e = Type.map_expr add_final_return e in
match e.eexpr with
| TFunction f ->
let f = (match follow f.tf_type with
| TAbstract ({ a_path = [],"Void" },[]) -> f
| t -> { f with tf_expr = loop f.tf_expr t }
) in
{ e with eexpr = TFunction f }
| _ -> e
let rec wrap_js_exceptions com e =
let rec is_error t =
match follow t with
| TInst ({cl_path = (["js"],"Error")},_) -> true
| TInst ({cl_super = Some (csup,tl)}, _) -> is_error (TInst (csup,tl))
| _ -> false
in
let rec loop e =
match e.eexpr with
| TThrow eerr when not (is_error eerr.etype) ->
let terr = List.find (fun mt -> match mt with TClassDecl {cl_path = ["js";"_Boot"],"HaxeError"} -> true | _ -> false) com.types in
let cerr = match terr with TClassDecl c -> c | _ -> assert false in
let ewrap = { eerr with eexpr = TNew (cerr,[],[eerr]) } in
{ e with eexpr = TThrow ewrap }
| _ ->
Type.map_expr loop e
in
loop e
(* -------------------------------------------------------------------------- *)
(* CHECK LOCAL VARS INIT *)
let check_local_vars_init e =
let intersect vl1 vl2 =
PMap.mapi (fun v t -> t && PMap.find v vl2) vl1
in
let join vars cvars =
List.iter (fun v -> vars := intersect !vars v) cvars
in
let restore vars old_vars declared =
(* restore variables declared in this block to their previous state *)
vars := List.fold_left (fun acc v ->
try PMap.add v (PMap.find v old_vars) acc with Not_found -> PMap.remove v acc
) !vars declared;
in
let declared = ref [] in
let rec loop vars e =
match e.eexpr with
| TLocal v ->
let init = (try PMap.find v.v_id !vars with Not_found -> true) in
if not init then begin
if v.v_name = "this" then error "Missing this = value" e.epos
else error ("Local variable " ^ v.v_name ^ " used without being initialized") e.epos
end
| TVar (v,eo) ->
begin
match eo with
| None ->
declared := v.v_id :: !declared;
vars := PMap.add v.v_id false !vars
| Some e ->
loop vars e
end
| TBlock el ->
let old = !declared in
let old_vars = !vars in
declared := [];
List.iter (loop vars) el;
restore vars old_vars (List.rev !declared);
declared := old;
| TBinop (OpAssign,{ eexpr = TLocal v },e) when PMap.mem v.v_id !vars ->
loop vars e;
vars := PMap.add v.v_id true !vars
| TIf (e1,e2,eo) ->
loop vars e1;
let vbase = !vars in
loop vars e2;
(match eo with
| None -> vars := vbase
(* ignore else false cases (they are added by the side-effect handler) *)
| Some {eexpr = TConst (TBool(false))} -> ()
| Some e ->
let v1 = !vars in
vars := vbase;
loop vars e;
vars := intersect !vars v1)
| TWhile (cond,e,flag) ->
(match flag with
| NormalWhile when (match cond.eexpr with TParenthesis {eexpr = TConst (TBool true)} -> false | _ -> true) ->
loop vars cond;
let old = !vars in
loop vars e;
vars := old;
| _ ->
loop vars e;
loop vars cond)
| TTry (e,catches) ->
let cvars = List.map (fun (v,e) ->
let old = !vars in
loop vars e;
let v = !vars in
vars := old;
v
) catches in
loop vars e;
join vars cvars;
| TSwitch (e,cases,def) ->
loop vars e;
let cvars = List.map (fun (ec,e) ->
let old = !vars in
List.iter (loop vars) ec;
vars := old;
loop vars e;
let v = !vars in
vars := old;
v
) cases in
(match def with
| None when (match e.eexpr with TMeta((Meta.Exhaustive,_,_),_) | TParenthesis({eexpr = TMeta((Meta.Exhaustive,_,_),_)}) -> true | _ -> false) ->
(match cvars with
| cv :: cvars ->
PMap.iter (fun i b -> if b then vars := PMap.add i b !vars) cv;
join vars cvars
| [] -> ())
| None -> ()
| Some e ->
loop vars e;
join vars cvars)
(* mark all reachable vars as initialized, since we don't exit the block *)
| TBreak | TContinue | TReturn None ->
vars := PMap.map (fun _ -> true) !vars
| TThrow e | TReturn (Some e) ->
loop vars e;
vars := PMap.map (fun _ -> true) !vars
| _ ->
Type.iter (loop vars) e
in
loop (ref PMap.empty) e;
e
(* -------------------------------------------------------------------------- *)
(* BLOCK VARIABLES CAPTURE *)
(*
For some platforms, it will simply mark the variables which are used in closures
using the v_capture flag so it can be processed in a more optimized
For Flash/JS platforms, it will ensure that variables used in loop sub-functions
have an unique scope. It transforms the following expression :
for( x in array )
funs.push(function() return x++);
Into the following :
for( _x in array ) {
var x = [_x];
funs.push(function(x) { function() return x[0]++; }(x));
}
*)
type usage =
| Block of ((usage -> unit) -> unit)
| Loop of ((usage -> unit) -> unit)
| Function of ((usage -> unit) -> unit)
| Declare of tvar
| Use of tvar
| Assign of tvar
let rec local_usage f e =
match e.eexpr with
| TBinop ((OpAssign | OpAssignOp _), { eexpr = TLocal v }, e2) ->
local_usage f e2;
f (Assign v)
| TUnop ((Increment | Decrement), _, { eexpr = TLocal v }) ->
f (Assign v)
| TLocal v ->
f (Use v)
| TVar (v,eo) ->
(match eo with None -> () | Some e -> local_usage f e);
f (Declare v);
| TFunction tf ->
let cc f =
List.iter (fun (v,_) -> f (Declare v)) tf.tf_args;
local_usage f tf.tf_expr;
in
f (Function cc)
| TBlock l ->
f (Block (fun f -> List.iter (local_usage f) l))
| TFor (v,it,e) ->
local_usage f it;
f (Loop (fun f ->
f (Declare v);
local_usage f e;
))
| TWhile _ ->
f (Loop (fun f ->
iter (local_usage f) e
))
| TTry (e,catchs) ->
local_usage f e;
List.iter (fun (v,e) ->
f (Block (fun f ->
f (Declare v);
local_usage f e;
))
) catchs;
| _ ->
iter (local_usage f) e
let captured_vars com e =
let t = com.basic in
let impl = match com.platform with
(* optimized version for C#/Java - use native arrays *)
| Cs | Java ->
let cnativearray =
match (List.find (fun md -> match md with
| TClassDecl ({ cl_path = ["cs"|"java"],"NativeArray" }) -> true
| _ -> false
) com.types)
with TClassDecl cl -> cl | _ -> assert false
in
object
method captured_type t = TInst (cnativearray,[t])
method mk_ref v ve p =
match ve with
| None ->
let eone = mk (TConst (TInt (Int32.of_int 1))) t.tint p in
let t = match v.v_type with TInst (_, [t]) -> t | _ -> assert false in
mk (TNew (cnativearray,[t],[eone])) v.v_type p
| Some e ->
{ (Optimizer.mk_untyped_call "__array__" p [e]) with etype = v.v_type }
method mk_ref_access e v =
mk (TArray ({ e with etype = v.v_type }, mk (TConst (TInt 0l)) t.tint e.epos)) e.etype e.epos
method mk_init av v pos =
let elocal = mk (TLocal v) v.v_type pos in
let earray = { (Optimizer.mk_untyped_call "__array__" pos [elocal]) with etype = av.v_type } in
mk (TVar (av,Some earray)) t.tvoid pos
end
(* default implementation - use haxe array *)
| _ ->
object
method captured_type = t.tarray
method mk_ref v ve p =
mk (TArrayDecl (match ve with None -> [] | Some e -> [e])) v.v_type p
method mk_ref_access e v =
mk (TArray ({ e with etype = v.v_type }, mk (TConst (TInt 0l)) t.tint e.epos)) e.etype e.epos
method mk_init av v pos =
mk (TVar (av,Some (mk (TArrayDecl [mk (TLocal v) v.v_type pos]) av.v_type pos))) t.tvoid pos
end
in
let mk_var v used =
let v2 = alloc_var v.v_name (PMap.find v.v_id used) in
v2.v_meta <- v.v_meta;
v2
in
let rec wrap used e =
match e.eexpr with
| TVar (v,ve) ->
let v,ve =
if PMap.mem v.v_id used then
v, Some (impl#mk_ref v (Option.map (wrap used) ve) e.epos)
else
v, (match ve with None -> None | Some e -> Some (wrap used e))
in
{ e with eexpr = TVar (v,ve) }
| TLocal v when PMap.mem v.v_id used ->
impl#mk_ref_access e v
| TFor (v,it,expr) when PMap.mem v.v_id used ->
let vtmp = mk_var v used in
let it = wrap used it in
let expr = wrap used expr in
mk (TFor (vtmp,it,Type.concat (impl#mk_init v vtmp e.epos) expr)) e.etype e.epos
| TTry (expr,catchs) ->
let catchs = List.map (fun (v,e) ->
let e = wrap used e in
try
let vtmp = mk_var v used in
vtmp, Type.concat (impl#mk_init v vtmp e.epos) e
with Not_found ->
v, e
) catchs in
mk (TTry (wrap used expr,catchs)) e.etype e.epos
| TFunction f ->
(*
list variables that are marked as used, but also used in that
function and which are not declared inside it !
*)
let fused = ref PMap.empty in
let tmp_used = ref used in
let rec browse = function
| Block f | Loop f | Function f -> f browse
| Use v | Assign v ->
if PMap.mem v.v_id !tmp_used then fused := PMap.add v.v_id v !fused;
| Declare v ->
tmp_used := PMap.remove v.v_id !tmp_used
in
local_usage browse e;
let vars = PMap.fold (fun v acc -> v :: acc) !fused [] in
(* in case the variable has been marked as used in a parallel scope... *)
let fexpr = ref (wrap used f.tf_expr) in
let fargs = List.map (fun (v,o) ->
if PMap.mem v.v_id used then
let vtmp = mk_var v used in
fexpr := Type.concat (impl#mk_init v vtmp e.epos) !fexpr;
vtmp, o
else
v, o
) f.tf_args in
let e = { e with eexpr = TFunction { f with tf_args = fargs; tf_expr = !fexpr } } in
(*
Create a new function scope to make sure that the captured loop variable
will not be overwritten in next loop iteration
*)
if com.config.pf_capture_policy = CPLoopVars then
mk (TCall (
Codegen.mk_parent (mk (TFunction {
tf_args = List.map (fun v -> v, None) vars;
tf_type = e.etype;
tf_expr = mk_block (mk (TReturn (Some e)) e.etype e.epos);
}) (TFun (List.map (fun v -> v.v_name,false,v.v_type) vars,e.etype)) e.epos),
List.map (fun v -> mk (TLocal v) v.v_type e.epos) vars)
) e.etype e.epos
else
e
| _ ->
map_expr (wrap used) e
and do_wrap used e =
if PMap.is_empty used then
e
else
let used = PMap.map (fun v ->
let vt = v.v_type in
v.v_type <- impl#captured_type vt;
v.v_capture <- true;
vt
) used in
wrap used e
and out_loop e =
match e.eexpr with
| TFor _ | TWhile _ ->
(*
collect variables that are declared in loop but used in subfunctions
*)
let vars = ref PMap.empty in
let used = ref PMap.empty in
let depth = ref 0 in
let rec collect_vars in_loop = function
| Block f ->
let old = !vars in
f (collect_vars in_loop);
vars := old;
| Loop f ->
let old = !vars in
f (collect_vars true);
vars := old;
| Function f ->
incr depth;
f (collect_vars false);
decr depth;
| Declare v ->
if in_loop then vars := PMap.add v.v_id !depth !vars;
| Use v | Assign v ->
try
let d = PMap.find v.v_id !vars in
if d <> !depth then used := PMap.add v.v_id v !used;
with Not_found ->
()
in
local_usage (collect_vars false) e;
do_wrap !used e
| _ ->
map_expr out_loop e
and all_vars e =
let vars = ref PMap.empty in
let used = ref PMap.empty in
let assigned = ref PMap.empty in
let depth = ref 0 in
let rec collect_vars = function
| Block f ->
let old = !vars in
f collect_vars;
vars := old;
| Loop f ->
let old = !vars in
f collect_vars;
vars := old;
| Function f ->
incr depth;
f collect_vars;
decr depth;
| Declare v ->
vars := PMap.add v.v_id !depth !vars;
| Use v ->
(try
let d = PMap.find v.v_id !vars in
if d <> !depth then used := PMap.add v.v_id v !used;
with Not_found -> ())
| Assign v ->
(try
let d = PMap.find v.v_id !vars in
(* different depth - needs wrap *)
if d <> !depth then begin
used := PMap.add v.v_id v !used;
assigned := PMap.add v.v_id v !assigned;
end
(* same depth but assigned after being used on a different depth - needs wrap *)
else if PMap.mem v.v_id !used then
assigned := PMap.add v.v_id v !assigned;
with Not_found -> ())
in
local_usage collect_vars e;
(* mark all capture variables - also used in rename_local_vars at later stage *)
PMap.iter (fun _ v -> v.v_capture <- true) !used;
!assigned
in
let captured = all_vars e in
match com.config.pf_capture_policy with
| CPNone -> e
| CPWrapRef -> do_wrap captured e
| CPLoopVars -> out_loop e
(* -------------------------------------------------------------------------- *)
(* RENAME LOCAL VARS *)
let rename_local_vars ctx e =
let cfg = ctx.com.config in
let all_scope = (not cfg.pf_captured_scope) || (not cfg.pf_locals_scope) in
let vars = ref PMap.empty in
let all_vars = ref PMap.empty in
let vtemp = alloc_var "~" t_dynamic in
let rebuild_vars = ref false in
let rebuild m =
PMap.fold (fun v acc -> PMap.add v.v_name v acc) m PMap.empty
in
let save() =
let old = !vars in
if cfg.pf_unique_locals || not cfg.pf_locals_scope then (fun() -> ()) else (fun() -> vars := if !rebuild_vars then rebuild old else old)
in
let rename vars v =
let count = ref 1 in
while PMap.mem (v.v_name ^ string_of_int !count) vars do
incr count;
done;
v.v_name <- v.v_name ^ string_of_int !count;
in
let declare v p =
(match follow v.v_type with
| TAbstract ({a_path = [],"Void"},_) -> error "Arguments and variables of type Void are not allowed" p
| _ -> ());
(* chop escape char for all local variables generated *)
if is_gen_local v then v.v_name <- "_g" ^ String.sub v.v_name 1 (String.length v.v_name - 1);
let look_vars = (if not cfg.pf_captured_scope && v.v_capture then !all_vars else !vars) in
(try
let v2 = PMap.find v.v_name look_vars in
(*
block_vars will create some wrapper-functions that are declaring
the same variable twice. In that case do not perform a rename since
we are sure it's actually the same variable
*)
if v == v2 then raise Not_found;
rename look_vars v;
with Not_found ->
());
vars := PMap.add v.v_name v !vars;
if all_scope then all_vars := PMap.add v.v_name v !all_vars;
in
(*
This is quite a rare case, when a local variable would otherwise prevent
accessing a type because it masks the type value or the package name.
*)
let check t =
match (t_infos t).mt_path with
| [], name | name :: _, _ ->
let vars = if cfg.pf_locals_scope then vars else all_vars in
(try
let v = PMap.find name !vars in
if v == vtemp then raise Not_found; (* ignore *)
rename (!vars) v;
rebuild_vars := true;
vars := PMap.add v.v_name v !vars
with Not_found ->
());
vars := PMap.add name vtemp !vars
in
let check_type t =
match follow t with
| TInst (c,_) -> check (TClassDecl c)
| TEnum (e,_) -> check (TEnumDecl e)
| TType (t,_) -> check (TTypeDecl t)
| TAbstract (a,_) -> check (TAbstractDecl a)
| TMono _ | TLazy _ | TAnon _ | TDynamic _ | TFun _ -> ()
in
let rec loop e =
match e.eexpr with
| TVar (v,eo) ->
if not cfg.pf_locals_scope then declare v e.epos;
(match eo with None -> () | Some e -> loop e);
if cfg.pf_locals_scope then declare v e.epos;
| TFunction tf ->
let old = save() in
List.iter (fun (v,_) -> declare v e.epos) tf.tf_args;
loop tf.tf_expr;
old()
| TBlock el ->
let old = save() in
(* we have to look ahead for vars on these targets (issue #3344) *)
begin match ctx.com.platform with
| Js ->
let rec check_var e = match e.eexpr with
| TVar (v,eo) ->
(match eo with None -> () | Some e -> loop e);
declare v e.epos
| TBlock _ ->
()
| _ ->
Type.iter check_var e
in
List.iter check_var el
| _ ->
()
end;
List.iter loop el;
old()
| TFor (v,it,e1) ->
loop it;
let old = save() in
declare v e.epos;
loop e1;
old()
| TTry (e,catchs) ->
loop e;
List.iter (fun (v,e) ->
let old = save() in
declare v e.epos;
check_type v.v_type;
loop e;
old()
) catchs;
| TTypeExpr t ->
check t
| TNew (c,_,_) ->
Type.iter loop e;
check (TClassDecl c);
| TCast (e,Some t) ->
loop e;
check t;
| TConst TSuper ->
check_type e.etype
| _ ->
Type.iter loop e
in
declare (alloc_var "this" t_dynamic) Ast.null_pos; (* force renaming of 'this' vars in abstract *)
begin match ctx.curclass.cl_path with
| s :: _,_ | [],s -> declare (alloc_var s t_dynamic) Ast.null_pos
end;
loop e;
e
let check_unification ctx e t =
begin match e.eexpr,t with
| TLocal v,TType({t_path = ["cs"],("Ref" | "Out")},_) ->
(* TODO: this smells of hack, but we have to deal with it somehow *)
v.v_capture <- true
| _ ->
()
end;
e
(* PASS 1 end *)
(* Saves a class state so it can be restored later, e.g. after DCE or native path rewrite *)
let save_class_state ctx t = match t with
| TClassDecl c ->
let mk_field_restore f =
let rec mk_overload_restore f =
f.cf_name,f.cf_kind,f.cf_expr,f.cf_type,f.cf_meta,f.cf_params
in
( f,mk_overload_restore f, List.map (fun f -> f,mk_overload_restore f) f.cf_overloads )
in
let restore_field (f,res,overloads) =
let restore_field (f,(name,kind,expr,t,meta,params)) =
f.cf_name <- name; f.cf_kind <- kind; f.cf_expr <- expr; f.cf_type <- t; f.cf_meta <- meta; f.cf_params <- params;
f
in
let f = restore_field (f,res) in
f.cf_overloads <- List.map restore_field overloads;
f
in
let mk_pmap lst =
List.fold_left (fun pmap f -> PMap.add f.cf_name f pmap) PMap.empty lst
in
let meta = c.cl_meta and path = c.cl_path and ext = c.cl_extern and over = c.cl_overrides in
let sup = c.cl_super and impl = c.cl_implements in
let csr = Option.map (mk_field_restore) c.cl_constructor in
let ofr = List.map (mk_field_restore) c.cl_ordered_fields in
let osr = List.map (mk_field_restore) c.cl_ordered_statics in
let init = c.cl_init in
c.cl_restore <- (fun() ->
c.cl_super <- sup;
c.cl_implements <- impl;
c.cl_meta <- meta;
c.cl_extern <- ext;
c.cl_path <- path;
c.cl_init <- init;
c.cl_ordered_fields <- List.map restore_field ofr;
c.cl_ordered_statics <- List.map restore_field osr;
c.cl_fields <- mk_pmap c.cl_ordered_fields;
c.cl_statics <- mk_pmap c.cl_ordered_statics;
c.cl_constructor <- Option.map restore_field csr;
c.cl_overrides <- over;
)
| _ ->
()
(* PASS 2 begin *)
let rec is_removable_class c =
match c.cl_kind with
| KGeneric ->
(Meta.has Meta.Remove c.cl_meta ||
(match c.cl_super with
| Some (c,_) -> is_removable_class c
| _ -> false) ||
List.exists (fun (_,t) -> match follow t with
| TInst(c,_) ->
Codegen.has_ctor_constraint c
| _ ->
false
) c.cl_params)
| KTypeParameter _ ->
(* this shouldn't happen, have to investigate (see #4092) *)
true
| _ ->
false
let remove_generic_base ctx t = match t with
| TClassDecl c when is_removable_class c ->
c.cl_extern <- true
| _ ->
()
(* Removes extern and macro fields, also checks for Void fields *)
let remove_extern_fields ctx t = match t with
| TClassDecl c ->
if not (Common.defined ctx.com Define.DocGen) then begin
c.cl_ordered_fields <- List.filter (fun f ->
let b = Codegen.is_removable_field ctx f in
if b then c.cl_fields <- PMap.remove f.cf_name c.cl_fields;
not b
) c.cl_ordered_fields;
c.cl_ordered_statics <- List.filter (fun f ->
let b = Codegen.is_removable_field ctx f in
if b then c.cl_statics <- PMap.remove f.cf_name c.cl_statics;
not b
) c.cl_ordered_statics;
end
| _ ->
()
(* PASS 2 end *)
(* PASS 3 begin *)
(* Checks if a private class' path clashes with another path *)
let check_private_path ctx t = match t with
| TClassDecl c when c.cl_private ->
let rpath = (fst c.cl_module.m_path,"_" ^ snd c.cl_module.m_path) in
if Hashtbl.mem ctx.g.types_module rpath then error ("This private class name will clash with " ^ s_type_path rpath) c.cl_pos;
| _ ->
()
(* Rewrites class or enum paths if @:native metadata is set *)
let apply_native_paths ctx t =
let get_native_name meta =
let rec get_native meta = match meta with
| [] -> raise Not_found
| (Meta.Native,[v],p as meta) :: _ ->
meta
| _ :: meta ->
get_native meta
in
let (_,e,mp) = get_native meta in
match e with
| [Ast.EConst (Ast.String name),p] ->
name,p
| [] ->
raise Not_found
| _ ->
error "String expected" mp
in
let get_real_name meta name =
let name',p = get_native_name meta in
(Meta.RealPath,[Ast.EConst (Ast.String (name)), p], p), name'
in
let get_real_path meta path =
let name,p = get_native_name meta in
(Meta.RealPath,[Ast.EConst (Ast.String (s_type_path path)), p], p), parse_path name
in
try
(match t with
| TClassDecl c ->
let did_change = ref false in
let field cf = try
let meta,name = get_real_name cf.cf_meta cf.cf_name in
cf.cf_name <- name;
cf.cf_meta <- meta :: cf.cf_meta;
List.iter (fun cf -> cf.cf_name <- name) cf.cf_overloads;
did_change := true
with Not_found ->
()
in
let fields cfs old_map =
did_change := false;
List.iter field cfs;
if !did_change then
List.fold_left (fun map f -> PMap.add f.cf_name f map) PMap.empty cfs
else
old_map
in
c.cl_fields <- fields c.cl_ordered_fields c.cl_fields;
c.cl_statics <- fields c.cl_ordered_statics c.cl_statics;
let meta,path = get_real_path c.cl_meta c.cl_path in
c.cl_meta <- meta :: c.cl_meta;
c.cl_path <- path;
| TEnumDecl e ->
let meta,path = get_real_path e.e_meta e.e_path in
e.e_meta <- meta :: e.e_meta;
e.e_path <- path;
| TAbstractDecl a ->
let meta,path = get_real_path a.a_meta a.a_path in
a.a_meta <- meta :: a.a_meta;
a.a_path <- path;
| _ ->
())
with Not_found ->
()
(* Adds the __rtti field if required *)
let add_rtti ctx t =
let rec has_rtti c =
Meta.has Meta.Rtti c.cl_meta || match c.cl_super with None -> false | Some (csup,_) -> has_rtti csup
in
match t with
| TClassDecl c when has_rtti c && not (PMap.mem "__rtti" c.cl_statics) ->
let f = mk_field "__rtti" ctx.t.tstring c.cl_pos in
let str = Genxml.gen_type_string ctx.com t in
f.cf_expr <- Some (mk (TConst (TString str)) f.cf_type c.cl_pos);
c.cl_ordered_statics <- f :: c.cl_ordered_statics;
c.cl_statics <- PMap.add f.cf_name f c.cl_statics;
| _ ->
()
(* Adds member field initializations as assignments to the constructor *)
let add_field_inits ctx t =
let is_as3 = Common.defined ctx.com Define.As3 && not ctx.in_macro in
let apply c =
let ethis = mk (TConst TThis) (TInst (c,List.map snd c.cl_params)) c.cl_pos in
(* TODO: we have to find a variable name which is not used in any of the functions *)
let v = alloc_var "_g" ethis.etype in
let need_this = ref false in
let inits,fields = List.fold_left (fun (inits,fields) cf ->
match cf.cf_kind,cf.cf_expr with
| Var _, Some _ ->
if is_as3 then (inits, cf :: fields) else (cf :: inits, cf :: fields)
| Method MethDynamic, Some e when is_as3 ->
(* TODO : this would have a better place in genSWF9 I think - NC *)
(* we move the initialization of dynamic functions to the constructor and also solve the
'this' problem along the way *)
let rec use_this v e = match e.eexpr with
| TConst TThis ->
need_this := true;
mk (TLocal v) v.v_type e.epos
| _ -> Type.map_expr (use_this v) e
in
let e = Type.map_expr (use_this v) e in
let cf2 = {cf with cf_expr = Some e} in
(* if the method is an override, we have to remove the class field to not get invalid overrides *)
let fields = if List.memq cf c.cl_overrides then begin
c.cl_fields <- PMap.remove cf.cf_name c.cl_fields;
fields
end else
cf2 :: fields
in
(cf2 :: inits, fields)
| _ -> (inits, cf :: fields)
) ([],[]) c.cl_ordered_fields in
c.cl_ordered_fields <- (List.rev fields);
match inits with
| [] -> ()
| _ ->
let el = List.map (fun cf ->
match cf.cf_expr with
| None -> assert false
| Some e ->
let lhs = mk (TField(ethis,FInstance (c,List.map snd c.cl_params,cf))) cf.cf_type e.epos in
cf.cf_expr <- None;
let eassign = mk (TBinop(OpAssign,lhs,e)) e.etype e.epos in
if is_as3 then begin
let echeck = mk (TBinop(OpEq,lhs,(mk (TConst TNull) lhs.etype e.epos))) ctx.com.basic.tbool e.epos in
mk (TIf(echeck,eassign,None)) eassign.etype e.epos
end else
eassign;
) inits in
let el = if !need_this then (mk (TVar((v, Some ethis))) ethis.etype ethis.epos) :: el else el in
match c.cl_constructor with
| None ->
let ct = TFun([],ctx.com.basic.tvoid) in
let ce = mk (TFunction {
tf_args = [];
tf_type = ctx.com.basic.tvoid;
tf_expr = mk (TBlock el) ctx.com.basic.tvoid c.cl_pos;
}) ct c.cl_pos in
let ctor = mk_field "new" ct c.cl_pos in
ctor.cf_kind <- Method MethNormal;
c.cl_constructor <- Some { ctor with cf_expr = Some ce };
| Some cf ->
match cf.cf_expr with
| Some { eexpr = TFunction f } ->
let bl = match f.tf_expr with {eexpr = TBlock b } -> b | x -> [x] in
let ce = mk (TFunction {f with tf_expr = mk (TBlock (el @ bl)) ctx.com.basic.tvoid c.cl_pos }) cf.cf_type cf.cf_pos in
c.cl_constructor <- Some {cf with cf_expr = Some ce }
| _ ->
assert false
in
match t with
| TClassDecl c ->
apply c
| _ ->
()
(* Adds the __meta__ field if required *)
let add_meta_field ctx t = match t with
| TClassDecl c ->
(match Codegen.build_metadata ctx.com t with
| None -> ()
| Some e ->
let f = mk_field "__meta__" t_dynamic c.cl_pos in
f.cf_expr <- Some e;
c.cl_ordered_statics <- f :: c.cl_ordered_statics;
c.cl_statics <- PMap.add f.cf_name f c.cl_statics)
| _ ->
()
(* Removes interfaces tagged with @:remove metadata *)
let check_remove_metadata ctx t = match t with
| TClassDecl c ->
c.cl_implements <- List.filter (fun (c,_) -> not (Meta.has Meta.Remove c.cl_meta)) c.cl_implements;
| _ ->
()
(* Checks for Void class fields *)
let check_void_field ctx t = match t with
| TClassDecl c ->
let check f =
match follow f.cf_type with TAbstract({a_path=[],"Void"},_) -> error "Fields of type Void are not allowed" f.cf_pos | _ -> ();
in
List.iter check c.cl_ordered_fields;
List.iter check c.cl_ordered_statics;
| _ ->
()
(* Interfaces have no 'super', but can extend many other interfaces.
This makes the first extended (implemented) interface the super for efficiency reasons (you can get one for 'free')
and leaves the remaining ones as 'implemented' *)
let promote_first_interface_to_super ctx t = match t with
| TClassDecl c when c.cl_interface ->
begin match c.cl_implements with
| ({ cl_path = ["cpp";"rtti"],_ },_ ) :: _ -> ()
| first_interface :: remaining ->
c.cl_super <- Some first_interface;
c.cl_implements <- remaining
| _ -> ()
end
| _ ->
()
let commit_features ctx t =
let m = (t_infos t).mt_module in
Hashtbl.iter (fun k v ->
Common.add_feature ctx.com k;
) m.m_extra.m_features
let check_reserved_type_paths ctx t =
let check path pos =
if List.mem path ctx.com.config.pf_reserved_type_paths then
ctx.com.warning ("Type path " ^ (s_type_path path) ^ " is reserved on this target") pos
in
match t with
| TClassDecl c when not c.cl_extern -> check c.cl_path c.cl_pos
| TEnumDecl e when not e.e_extern -> check e.e_path e.e_pos
| _ -> ()
(* PASS 3 end *)
let run_expression_filters ctx filters t =
let run e =
List.fold_left (fun e f -> f e) e filters
in
match t with
| TClassDecl c when is_removable_class c -> ()
| TClassDecl c ->
ctx.curclass <- c;
let rec process_field f =
(match f.cf_expr with
| Some e when not (Codegen.is_removable_field ctx f) ->
Codegen.AbstractCast.cast_stack := f :: !Codegen.AbstractCast.cast_stack;
f.cf_expr <- Some (run e);
Codegen.AbstractCast.cast_stack := List.tl !Codegen.AbstractCast.cast_stack;
| _ -> ());
List.iter process_field f.cf_overloads
in
List.iter process_field c.cl_ordered_fields;
List.iter process_field c.cl_ordered_statics;
(match c.cl_constructor with
| None -> ()
| Some f -> process_field f);
(match c.cl_init with
| None -> ()
| Some e ->
c.cl_init <- Some (run e));
| TEnumDecl _ -> ()
| TTypeDecl _ -> ()
| TAbstractDecl _ -> ()
let pp_counter = ref 1
let is_cached t =
let m = (t_infos t).mt_module.m_extra in
if m.m_processed = 0 then m.m_processed <- !pp_counter;
m.m_processed <> !pp_counter
let apply_filters_once ctx filters t =
if not (is_cached t) then run_expression_filters ctx filters t
let next_compilation() =
incr pp_counter
let iter_expressions fl mt =
match mt with
| TClassDecl c ->
let field cf = match cf.cf_expr with
| None -> ()
| Some e -> List.iter (fun f -> f e) fl
in
List.iter field c.cl_ordered_statics;
List.iter field c.cl_ordered_fields;
(match c.cl_constructor with None -> () | Some cf -> field cf)
| _ ->
()
let run com tctx main =
begin match com.display with
| DMUsage | DMPosition ->
Codegen.detect_usage com;
| _ ->
()
end;
if not (Common.defined com Define.NoDeprecationWarnings) then
Codegen.DeprecationCheck.run com;
let use_static_analyzer = Common.defined com Define.Analyzer in
(* this part will be a bit messy until we make the analyzer the default *)
let new_types = List.filter (fun t -> not (is_cached t)) com.types in
if use_static_analyzer then begin
(* PASS 1: general expression filters *)
let filters = [
Codegen.UnificationCallback.run (check_unification tctx);
Codegen.AbstractCast.handle_abstract_casts tctx;
Optimizer.inline_constructors tctx;
Optimizer.reduce_expression tctx;
blockify_ast;
captured_vars com;
] in
List.iter (run_expression_filters tctx filters) new_types;
Analyzer.Run.run_on_types tctx new_types;
List.iter (iter_expressions [verify_ast]) new_types;
let filters = [
Optimizer.sanitize com;
if com.config.pf_add_final_return then add_final_return else (fun e -> e);
if com.platform = Js then wrap_js_exceptions com else (fun e -> e);
rename_local_vars tctx;
] in
List.iter (run_expression_filters tctx filters) new_types;
end else begin
(* PASS 1: general expression filters *)
let filters = [
Codegen.UnificationCallback.run (check_unification tctx);
Codegen.AbstractCast.handle_abstract_casts tctx;
blockify_ast;
check_local_vars_init;
( if (Common.defined com Define.NoSimplify) || (Common.defined com Define.Cppia) ||
( match com.platform with Cpp -> false | _ -> true ) then
fun e -> e
else
fun e ->
let save = save_locals tctx in
let timer = timer "analyzer-simplify-apply" in
let e = try snd (Analyzer.Simplifier.apply com e) with Exit -> e in
timer();
save();
e );
if com.foptimize then (fun e -> Optimizer.reduce_expression tctx (Optimizer.inline_constructors tctx e)) else Optimizer.sanitize com;
captured_vars com;
promote_complex_rhs com;
if com.config.pf_add_final_return then add_final_return else (fun e -> e);
if com.platform = Js then wrap_js_exceptions com else (fun e -> e);
rename_local_vars tctx;
] in
List.iter (run_expression_filters tctx filters) new_types;
List.iter (iter_expressions [verify_ast]) new_types;
end;
next_compilation();
List.iter (fun f -> f()) (List.rev com.filters); (* macros onGenerate etc. *)
List.iter (save_class_state tctx) new_types;
List.iter (fun t ->
remove_generic_base tctx t;
remove_extern_fields tctx t;
) com.types;
(* update cache dependencies before DCE is run *)
Codegen.update_cache_dependencies com;
(* check @:remove metadata before DCE so it is ignored there (issue #2923) *)
List.iter (check_remove_metadata tctx) com.types;
(* DCE *)
let dce_mode = if Common.defined com Define.As3 then
"no"
else
(try Common.defined_value com Define.Dce with _ -> "no")
in
begin match dce_mode with
| "full" -> Dce.run com main (not (Common.defined com Define.Interp))
| "std" -> Dce.run com main false
| "no" -> Dce.fix_accessors com
| _ -> failwith ("Unknown DCE mode " ^ dce_mode)
end;
(* always filter empty abstract implementation classes (issue #1885) *)
List.iter (fun mt -> match mt with
| TClassDecl({cl_kind = KAbstractImpl _} as c) when c.cl_ordered_statics = [] && c.cl_ordered_fields = [] && not (Meta.has Meta.Used c.cl_meta) ->
c.cl_extern <- true
| TClassDecl({cl_kind = KAbstractImpl a} as c) when Meta.has Meta.Enum a.a_meta ->
let is_runtime_field cf =
not (Meta.has Meta.Enum cf.cf_meta)
in
(* also filter abstract implementation classes that have only @:enum fields (issue #2858) *)
if not (List.exists is_runtime_field c.cl_ordered_statics) then
c.cl_extern <- true
| _ -> ()
) com.types;
(* PASS 3: type filters *)
let type_filters = [
check_private_path;
apply_native_paths;
add_rtti;
(match com.platform with | Java | Cs -> (fun _ _ -> ()) | _ -> add_field_inits);
add_meta_field;
check_void_field;
(match com.platform with | Cpp -> promote_first_interface_to_super | _ -> (fun _ _ -> ()) );
commit_features;
(if com.config.pf_reserved_type_paths <> [] then check_reserved_type_paths else (fun _ _ -> ()));
] in
List.iter (fun t -> List.iter (fun f -> f tctx t) type_filters) com.types
haxe_3.2.1+dfsg.orig/genas3.ml 0000664 0001750 0001750 00000105653 12607337712 016050 0 ustar andy andy 0000000 0000000 (*
* Copyright (C)2005-2013 Haxe Foundation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*)
open Type
open Common
type context_infos = {
com : Common.context;
}
type context = {
inf : context_infos;
ch : out_channel;
buf : Buffer.t;
path : path;
mutable get_sets : (string * bool,string) Hashtbl.t;
mutable curclass : tclass;
mutable tabs : string;
mutable in_value : tvar option;
mutable in_static : bool;
mutable handle_break : bool;
mutable imports : (string,string list list) Hashtbl.t;
mutable gen_uid : int;
mutable local_types : t list;
mutable constructor_block : bool;
mutable block_inits : (unit -> unit) option;
}
let follow = Abstract.follow_with_abstracts
let is_var_field f =
match f with
| FStatic (_,f) | FInstance (_,_,f) ->
(match f.cf_kind with Var _ | Method MethDynamic -> true | _ -> false)
| _ ->
false
let is_special_compare e1 e2 =
match e1.eexpr, e2.eexpr with
| TConst TNull, _ | _ , TConst TNull -> None
| _ ->
match follow e1.etype, follow e2.etype with
| TInst ({ cl_path = ["flash"],"NativeXml" } as c,_) , _ | _ , TInst ({ cl_path = ["flash"],"NativeXml" } as c,_) -> Some c
| _ -> None
let protect name =
match name with
| "Error" | "Namespace" -> "_" ^ name
| _ -> name
let s_path ctx stat path p =
match path with
| ([],name) ->
(match name with
| "Int" -> "int"
| "Float" -> "Number"
| "Dynamic" -> "Object"
| "Bool" -> "Boolean"
| "Enum" -> "Class"
| "EnumValue" -> "enum"
| _ -> name)
| (["flash"],"FlashXml__") ->
"Xml"
| (["flash";"errors"],"Error") ->
"Error"
| (["flash"],"Vector") ->
"Vector"
| (["flash";"xml"],"XML") ->
"XML"
| (["flash";"xml"],"XMLList") ->
"XMLList"
| ["flash";"utils"],"QName" ->
"QName"
| ["flash";"utils"],"Namespace" ->
"Namespace"
| (["haxe"],"Int32") when not stat ->
"int"
| (pack,name) ->
let name = protect name in
let packs = (try Hashtbl.find ctx.imports name with Not_found -> []) in
if not (List.mem pack packs) then Hashtbl.replace ctx.imports name (pack :: packs);
Ast.s_type_path (pack,name)
let reserved =
let h = Hashtbl.create 0 in
List.iter (fun l -> Hashtbl.add h l ())
(* these ones are defined in order to prevent recursion in some Std functions *)
["is";"as";"int";"uint";"const";"getTimer";"typeof";"parseInt";"parseFloat";
(* AS3 keywords which are not Haxe ones *)
"finally";"with";"final";"internal";"native";"namespace";"include";"delete";
(* some globals give some errors with Flex SDK as well *)
"print";"trace";
(* we don't include get+set since they are not 'real' keywords, but they can't be used as method names *)
"function";"class";"var";"if";"else";"while";"do";"for";"break";"continue";"return";"extends";"implements";
"import";"switch";"case";"default";"static";"public";"private";"try";"catch";"new";"this";"throw";"interface";
"override";"package";"null";"true";"false";"void"
];
h
(* "each", "label" : removed (actually allowed in locals and fields accesses) *)
let s_ident n =
if Hashtbl.mem reserved n then "_" ^ n else n
let valid_as3_ident s =
try
for i = 0 to String.length s - 1 do
match String.unsafe_get s i with
| 'a'..'z' | 'A'..'Z' | '$' | '_' -> ()
| '0'..'9' when i > 0 -> ()
| _ -> raise Exit
done;
true
with Exit ->
false
let anon_field s =
let s = s_ident s in
if not (valid_as3_ident s) then "\"" ^ s ^ "\"" else s
let rec create_dir acc = function
| [] -> ()
| d :: l ->
let dir = String.concat "/" (List.rev (d :: acc)) in
if not (Sys.file_exists dir) then Unix.mkdir dir 0o755;
create_dir (d :: acc) l
let init infos path =
let dir = infos.com.file :: fst path in
create_dir [] dir;
let ch = open_out (String.concat "/" dir ^ "/" ^ snd path ^ ".as") in
let imports = Hashtbl.create 0 in
Hashtbl.add imports (snd path) [fst path];
{
inf = infos;
tabs = "";
ch = ch;
path = path;
buf = Buffer.create (1 lsl 14);
in_value = None;
in_static = false;
handle_break = false;
imports = imports;
curclass = null_class;
gen_uid = 0;
local_types = [];
get_sets = Hashtbl.create 0;
constructor_block = false;
block_inits = None;
}
let close ctx =
begin match ctx.inf.com.main_class with
| Some tp when tp = ctx.curclass.cl_path ->
output_string ctx.ch "// Compile __main__.as instead\n";
| _ ->
()
end;
output_string ctx.ch (Printf.sprintf "package %s {\n" (String.concat "." (fst ctx.path)));
Hashtbl.iter (fun name paths ->
List.iter (fun pack ->
let path = pack, name in
if path <> ctx.path then output_string ctx.ch ("\timport " ^ Ast.s_type_path path ^ ";\n");
) paths
) ctx.imports;
output_string ctx.ch (Buffer.contents ctx.buf);
close_out ctx.ch
let gen_local ctx l =
ctx.gen_uid <- ctx.gen_uid + 1;
if ctx.gen_uid = 1 then l else l ^ string_of_int ctx.gen_uid
let spr ctx s = Buffer.add_string ctx.buf s
let print ctx = Printf.kprintf (fun s -> Buffer.add_string ctx.buf s)
let unsupported p = error "This expression cannot be generated to AS3" p
let newline ctx =
let rec loop p =
match Buffer.nth ctx.buf p with
| '}' | '{' | ':' | ';' -> print ctx "\n%s" ctx.tabs
| '\n' | '\t' -> loop (p - 1)
| _ -> print ctx ";\n%s" ctx.tabs
in
loop (Buffer.length ctx.buf - 1)
let block_newline ctx = match Buffer.nth ctx.buf (Buffer.length ctx.buf - 1) with
| '}' -> print ctx ";\n%s" ctx.tabs
| _ -> newline ctx
let rec concat ctx s f = function
| [] -> ()
| [x] -> f x
| x :: l ->
f x;
spr ctx s;
concat ctx s f l
let open_block ctx =
let oldt = ctx.tabs in
ctx.tabs <- "\t" ^ ctx.tabs;
(fun() -> ctx.tabs <- oldt)
let parent e =
match e.eexpr with
| TParenthesis _ -> e
| _ -> mk (TParenthesis e) e.etype e.epos
let default_value tstr =
match tstr with
| "int" | "uint" -> "0"
| "Number" -> "NaN"
| "Boolean" -> "false"
| _ -> "null"
let rec type_str ctx t p =
match t with
| TEnum _ | TInst _ when List.memq t ctx.local_types ->
"*"
| TAbstract (a,pl) when not (Ast.Meta.has Ast.Meta.CoreType a.a_meta) ->
type_str ctx (Abstract.get_underlying_type a pl) p
| TAbstract (a,_) ->
(match a.a_path with
| [], "Void" -> "void"
| [], "UInt" -> "uint"
| [], "Int" -> "int"
| [], "Float" -> "Number"
| [], "Bool" -> "Boolean"
| _ -> s_path ctx true a.a_path p)
| TEnum (e,_) ->
if e.e_extern then (match e.e_path with
| [], "Void" -> "void"
| [], "Bool" -> "Boolean"
| _ ->
let rec loop = function
| [] -> "Object"
| (Ast.Meta.FakeEnum,[Ast.EConst (Ast.Ident n),_],_) :: _ ->
(match n with
| "Int" -> "int"
| "UInt" -> "uint"
| _ -> n)
| _ :: l -> loop l
in
loop e.e_meta
) else
s_path ctx true e.e_path p
| TInst ({ cl_path = ["flash"],"Vector" },[pt]) ->
(match pt with
| TInst({cl_kind = KTypeParameter _},_) -> "*"
| _ -> "Vector.<" ^ type_str ctx pt p ^ ">")
| TInst (c,_) ->
(match c.cl_kind with
| KNormal | KGeneric | KGenericInstance _ | KAbstractImpl _ -> s_path ctx false c.cl_path p
| KTypeParameter _ | KExtension _ | KExpr _ | KMacroType | KGenericBuild _ -> "*")
| TFun _ ->
"Function"
| TMono r ->
(match !r with None -> "*" | Some t -> type_str ctx t p)
| TAnon _ | TDynamic _ ->
"*"
| TType (t,args) ->
(match t.t_path with
| [], "UInt" -> "uint"
| [] , "Null" ->
(match args with
| [t] ->
(match follow t with
| TAbstract ({ a_path = [],"UInt" },_)
| TAbstract ({ a_path = [],"Int" },_)
| TAbstract ({ a_path = [],"Float" },_)
| TAbstract ({ a_path = [],"Bool" },_)
| TInst ({ cl_path = [],"Int" },_)
| TInst ({ cl_path = [],"Float" },_)
| TEnum ({ e_path = [],"Bool" },_) -> "*"
| _ -> type_str ctx t p)
| _ -> assert false);
| _ -> type_str ctx (apply_params t.t_params args t.t_type) p)
| TLazy f ->
type_str ctx ((!f)()) p
let rec iter_switch_break in_switch e =
match e.eexpr with
| TFunction _ | TWhile _ | TFor _ -> ()
| TSwitch _ when not in_switch -> iter_switch_break true e
| TBreak when in_switch -> raise Exit
| _ -> iter (iter_switch_break in_switch) e
let handle_break ctx e =
let old_handle = ctx.handle_break in
try
iter_switch_break false e;
ctx.handle_break <- false;
(fun() -> ctx.handle_break <- old_handle)
with
Exit ->
spr ctx "try {";
let b = open_block ctx in
newline ctx;
ctx.handle_break <- true;
(fun() ->
b();
ctx.handle_break <- old_handle;
newline ctx;
spr ctx "} catch( e : * ) { if( e != \"__break__\" ) throw e; }";
)
let this ctx = if ctx.in_value <> None then "$this" else "this"
let generate_resources infos =
if Hashtbl.length infos.com.resources <> 0 then begin
let dir = (infos.com.file :: ["__res"]) in
create_dir [] dir;
let add_resource name data =
let name = Base64.str_encode name in
let ch = open_out_bin (String.concat "/" (dir @ [name])) in
output_string ch data;
close_out ch
in
Hashtbl.iter (fun name data -> add_resource name data) infos.com.resources;
let ctx = init infos ([],"__resources__") in
spr ctx "\timport flash.utils.Dictionary;\n";
spr ctx "\tpublic class __resources__ {\n";
spr ctx "\t\tpublic static var list:Dictionary;\n";
let inits = ref [] in
let k = ref 0 in
Hashtbl.iter (fun name _ ->
let varname = ("v" ^ (string_of_int !k)) in
k := !k + 1;
print ctx "\t\t[Embed(source = \"__res/%s\", mimeType = \"application/octet-stream\")]\n" (Base64.str_encode name);
print ctx "\t\tpublic static var %s:Class;\n" varname;
inits := ("list[\"" ^ Ast.s_escape name ^ "\"] = " ^ varname ^ ";") :: !inits;
) infos.com.resources;
spr ctx "\t\tstatic public function __init__():void {\n";
spr ctx "\t\t\tlist = new Dictionary();\n";
List.iter (fun init ->
print ctx "\t\t\t%s\n" init
) !inits;
spr ctx "\t\t}\n";
spr ctx "\t}\n";
spr ctx "}";
close ctx;
end
let gen_constant ctx p = function
| TInt i -> print ctx "%ld" i
| TFloat s -> spr ctx s
| TString s -> print ctx "\"%s\"" (Ast.s_escape s)
| TBool b -> spr ctx (if b then "true" else "false")
| TNull -> spr ctx "null"
| TThis -> spr ctx (this ctx)
| TSuper -> spr ctx "super"
let gen_function_header ctx name f params p =
let old = ctx.in_value in
let old_t = ctx.local_types in
let old_bi = ctx.block_inits in
ctx.in_value <- None;
ctx.local_types <- List.map snd params @ ctx.local_types;
let init () =
List.iter (fun (v,o) -> match o with
| Some c when is_nullable v.v_type && c <> TNull ->
newline ctx;
print ctx "if(%s==null) %s=" v.v_name v.v_name;
gen_constant ctx p c;
| _ -> ()
) f.tf_args;
ctx.block_inits <- None;
in
ctx.block_inits <- Some init;
print ctx "function%s(" (match name with None -> "" | Some (n,meta) ->
let rec loop = function
| [] -> n
| (Ast.Meta.Getter,[Ast.EConst (Ast.Ident i),_],_) :: _ -> "get " ^ i
| (Ast.Meta.Setter,[Ast.EConst (Ast.Ident i),_],_) :: _ -> "set " ^ i
| _ :: l -> loop l
in
" " ^ loop meta
);
concat ctx "," (fun (v,c) ->
match v.v_name with
| "__arguments__" ->
print ctx "...__arguments__"
| _ ->
let tstr = type_str ctx v.v_type p in
print ctx "%s : %s" (s_ident v.v_name) tstr;
match c with
| None ->
if ctx.constructor_block then print ctx " = %s" (default_value tstr);
| Some c ->
spr ctx " = ";
gen_constant ctx p c
) f.tf_args;
print ctx ") : %s " (type_str ctx f.tf_type p);
(fun () ->
ctx.in_value <- old;
ctx.local_types <- old_t;
ctx.block_inits <- old_bi;
)
let rec gen_call ctx e el r =
match e.eexpr , el with
| TCall (x,_) , el ->
spr ctx "(";
gen_value ctx e;
spr ctx ")";
spr ctx "(";
concat ctx "," (gen_value ctx) el;
spr ctx ")";
| TLocal { v_name = "__is__" } , [e1;e2] ->
gen_value ctx e1;
spr ctx " is ";
gen_value ctx e2;
| TLocal { v_name = "__in__" } , [e1;e2] ->
spr ctx "(";
gen_value ctx e1;
spr ctx " in ";
gen_value ctx e2;
spr ctx ")"
| TLocal { v_name = "__as__" }, [e1;e2] ->
gen_value ctx e1;
spr ctx " as ";
gen_value ctx e2;
| TLocal { v_name = "__int__" }, [e] ->
spr ctx "int(";
gen_value ctx e;
spr ctx ")";
| TLocal { v_name = "__float__" }, [e] ->
spr ctx "Number(";
gen_value ctx e;
spr ctx ")";
| TLocal { v_name = "__typeof__" }, [e] ->
spr ctx "typeof ";
gen_value ctx e;
| TLocal { v_name = "__keys__" }, [e] ->
let ret = (match ctx.in_value with None -> assert false | Some r -> r) in
print ctx "%s = new Array()" ret.v_name;
newline ctx;
let tmp = gen_local ctx "$k" in
print ctx "for(var %s : String in " tmp;
gen_value ctx e;
print ctx ") %s.push(%s)" ret.v_name tmp;
| TLocal { v_name = "__hkeys__" }, [e] ->
let ret = (match ctx.in_value with None -> assert false | Some r -> r) in
print ctx "%s = new Array()" ret.v_name;
newline ctx;
let tmp = gen_local ctx "$k" in
print ctx "for(var %s : String in " tmp;
gen_value ctx e;
print ctx ") %s.push(%s.substr(1))" ret.v_name tmp;
| TLocal { v_name = "__foreach__" }, [e] ->
let ret = (match ctx.in_value with None -> assert false | Some r -> r) in
print ctx "%s = new Array()" ret.v_name;
newline ctx;
let tmp = gen_local ctx "$k" in
print ctx "for each(var %s : * in " tmp;
gen_value ctx e;
print ctx ") %s.push(%s)" ret.v_name tmp;
| TLocal { v_name = "__new__" }, e :: args ->
spr ctx "new ";
gen_value ctx e;
spr ctx "(";
concat ctx "," (gen_value ctx) args;
spr ctx ")";
| TLocal { v_name = "__delete__" }, [e;f] ->
spr ctx "delete(";
gen_value ctx e;
spr ctx "[";
gen_value ctx f;
spr ctx "]";
spr ctx ")";
| TLocal { v_name = "__unprotect__" }, [e] ->
gen_value ctx e
| TLocal { v_name = "__vector__" }, [e] ->
spr ctx (type_str ctx r e.epos);
spr ctx "(";
gen_value ctx e;
spr ctx ")"
| TField (_, FStatic( { cl_path = (["flash"],"Lib") }, { cf_name = "as" })), [e1;e2] ->
gen_value ctx e1;
spr ctx " as ";
gen_value ctx e2
| TField (_, FStatic ({ cl_path = (["flash"],"Vector") }, cf)), args ->
(match cf.cf_name, args with
| "ofArray", [e] | "convert", [e] ->
(match follow r with
| TInst ({ cl_path = (["flash"],"Vector") },[t]) ->
print ctx "Vector.<%s>(" (type_str ctx t e.epos);
gen_value ctx e;
print ctx ")";
| _ -> assert false)
| _ -> assert false)
| TField(e1, (FAnon {cf_name = s} | FDynamic s)),[ef] when s = "map" || s = "filter" ->
spr ctx (s_path ctx true (["flash";],"Boot") e.epos);
gen_field_access ctx t_dynamic (s ^ "Dynamic");
spr ctx "(";
concat ctx "," (gen_value ctx) [e1;ef];
spr ctx ")"
| TField (ee,f), args when is_var_field f ->
spr ctx "(";
gen_value ctx e;
spr ctx ")";
spr ctx "(";
concat ctx "," (gen_value ctx) el;
spr ctx ")"
| _ ->
gen_value ctx e;
spr ctx "(";
concat ctx "," (gen_value ctx) el;
spr ctx ")"
and gen_value_op ctx e =
match e.eexpr with
| TBinop (op,_,_) when op = Ast.OpAnd || op = Ast.OpOr || op = Ast.OpXor ->
spr ctx "(";
gen_value ctx e;
spr ctx ")";
| _ ->
gen_value ctx e
and gen_field_access ctx t s =
let field c =
match fst c.cl_path, snd c.cl_path, s with
| [], "Math", "NaN"
| [], "Math", "NEGATIVE_INFINITY"
| [], "Math", "POSITIVE_INFINITY"
| [], "Math", "isFinite"
| [], "Math", "isNaN"
| [], "Date", "now"
| [], "Date", "fromTime"
| [], "Date", "fromString"
->
print ctx "[\"%s\"]" s
| [], "String", "charCodeAt" ->
spr ctx "[\"charCodeAtHX\"]"
| [], "Array", "map" ->
spr ctx "[\"mapHX\"]"
| [], "Array", "filter" ->
spr ctx "[\"filterHX\"]"
| [], "Date", "toString" ->
print ctx "[\"toStringHX\"]"
| [], "String", "cca" ->
print ctx ".charCodeAt"
| ["flash";"xml"], "XML", "namespace" ->
print ctx ".namespace"
| _ ->
print ctx ".%s" (s_ident s)
in
match follow t with
| TInst (c,_) -> field c
| TAnon a ->
(match !(a.a_status) with
| Statics c -> field c
| _ -> print ctx ".%s" (s_ident s))
| _ ->
print ctx ".%s" (s_ident s)
and gen_expr ctx e =
match e.eexpr with
| TConst c ->
gen_constant ctx e.epos c
| TLocal v ->
spr ctx (s_ident v.v_name)
| TArray ({ eexpr = TLocal { v_name = "__global__" } },{ eexpr = TConst (TString s) }) ->
let path = Ast.parse_path s in
spr ctx (s_path ctx false path e.epos)
| TArray (e1,e2) ->
gen_value ctx e1;
spr ctx "[";
gen_value ctx e2;
spr ctx "]";
| TBinop (Ast.OpEq,e1,e2) when (match is_special_compare e1 e2 with Some c -> true | None -> false) ->
let c = match is_special_compare e1 e2 with Some c -> c | None -> assert false in
gen_expr ctx (mk (TCall (mk (TField (mk (TTypeExpr (TClassDecl c)) t_dynamic e.epos,FDynamic "compare")) t_dynamic e.epos,[e1;e2])) ctx.inf.com.basic.tbool e.epos);
(* what is this used for? *)
(* | TBinop (op,{ eexpr = TField (e1,s) },e2) ->
gen_value_op ctx e1;
gen_field_access ctx e1.etype s;
print ctx " %s " (Ast.s_binop op);
gen_value_op ctx e2; *)
(* assignments to variable or dynamic methods fields on interfaces are generated as class["field"] = value *)
| TBinop (op,{eexpr = TField (ei, FInstance({cl_interface = true},_,{cf_kind = (Method MethDynamic | Var _); cf_name = s}))},e2) ->
gen_value ctx ei;
print ctx "[\"%s\"]" s;
print ctx " %s " (Ast.s_binop op);
gen_value_op ctx e2;
| TBinop (op,e1,e2) ->
gen_value_op ctx e1;
print ctx " %s " (Ast.s_binop op);
gen_value_op ctx e2;
(* variable fields and dynamic methods on interfaces are generated as (class["field"] as class) *)
| TField (ei, FInstance({cl_interface = true},_,{cf_kind = (Method MethDynamic | Var _); cf_name = s})) ->
spr ctx "(";
gen_value ctx ei;
print ctx "[\"%s\"]" s;
print ctx " as %s)" (type_str ctx e.etype e.epos);
| TField({eexpr = TArrayDecl _} as e1,s) ->
spr ctx "(";
gen_expr ctx e1;
spr ctx ")";
gen_field_access ctx e1.etype (field_name s)
| TEnumParameter (e,_,i) ->
gen_value ctx e;
print ctx ".params[%i]" i;
| TField (e,s) ->
gen_value ctx e;
gen_field_access ctx e.etype (field_name s)
| TTypeExpr t ->
spr ctx (s_path ctx true (t_path t) e.epos)
| TParenthesis e ->
spr ctx "(";
gen_value ctx e;
spr ctx ")";
| TMeta (_,e) ->
gen_expr ctx e
| TReturn eo ->
if ctx.in_value <> None then unsupported e.epos;
(match eo with
| None ->
spr ctx "return"
| Some e when (match follow e.etype with TEnum({ e_path = [],"Void" },[]) | TAbstract ({ a_path = [],"Void" },[]) -> true | _ -> false) ->
print ctx "{";
let bend = open_block ctx in
newline ctx;
gen_value ctx e;
newline ctx;
spr ctx "return";
bend();
newline ctx;
print ctx "}";
| Some e ->
spr ctx "return ";
gen_value ctx e);
| TBreak ->
if ctx.in_value <> None then unsupported e.epos;
if ctx.handle_break then spr ctx "throw \"__break__\"" else spr ctx "break"
| TContinue ->
if ctx.in_value <> None then unsupported e.epos;
spr ctx "continue"
| TBlock el ->
print ctx "{";
let bend = open_block ctx in
let cb = (if not ctx.constructor_block then
(fun () -> ())
else if not (Codegen.constructor_side_effects e) then begin
ctx.constructor_block <- false;
(fun () -> ())
end else begin
ctx.constructor_block <- false;
print ctx " if( !%s.skip_constructor ) {" (s_path ctx true (["flash"],"Boot") e.epos);
(fun() -> print ctx "}")
end) in
(match ctx.block_inits with None -> () | Some i -> i());
List.iter (fun e -> gen_block_element ctx e) el;
bend();
newline ctx;
cb();
print ctx "}";
| TFunction f ->
let h = gen_function_header ctx None f [] e.epos in
let old = ctx.in_static in
ctx.in_static <- true;
gen_expr ctx f.tf_expr;
ctx.in_static <- old;
h();
| TCall (v,el) ->
gen_call ctx v el e.etype
| TArrayDecl el ->
spr ctx "[";
concat ctx "," (gen_value ctx) el;
spr ctx "]"
| TThrow e ->
spr ctx "throw ";
gen_value ctx e;
| TVar (v,eo) ->
spr ctx "var ";
print ctx "%s : %s" (s_ident v.v_name) (type_str ctx v.v_type e.epos);
begin match eo with
| None -> ()
| Some e ->
spr ctx " = ";
gen_value ctx e
end
| TNew (c,params,el) ->
(match c.cl_path, params with
| (["flash"],"Vector"), [pt] -> print ctx "new Vector.<%s>(" (type_str ctx pt e.epos)
| _ -> print ctx "new %s(" (s_path ctx true c.cl_path e.epos));
concat ctx "," (gen_value ctx) el;
spr ctx ")"
| TIf (cond,e,eelse) ->
spr ctx "if";
gen_value ctx (parent cond);
spr ctx " ";
gen_expr ctx e;
(match eelse with
| None -> ()
| Some e ->
newline ctx;
spr ctx "else ";
gen_expr ctx e);
| TUnop (op,Ast.Prefix,e) ->
spr ctx (Ast.s_unop op);
gen_value ctx e
| TUnop (op,Ast.Postfix,e) ->
gen_value ctx e;
spr ctx (Ast.s_unop op)
| TWhile (cond,e,Ast.NormalWhile) ->
let handle_break = handle_break ctx e in
spr ctx "while";
gen_value ctx (parent cond);
spr ctx " ";
gen_expr ctx e;
handle_break();
| TWhile (cond,e,Ast.DoWhile) ->
let handle_break = handle_break ctx e in
spr ctx "do ";
gen_expr ctx e;
spr ctx " while";
gen_value ctx (parent cond);
handle_break();
| TObjectDecl fields ->
spr ctx "{ ";
concat ctx ", " (fun (f,e) -> print ctx "%s : " (anon_field f); gen_value ctx e) fields;
spr ctx "}"
| TFor (v,it,e) ->
let handle_break = handle_break ctx e in
let tmp = gen_local ctx "$it" in
print ctx "{ var %s : * = " tmp;
gen_value ctx it;
newline ctx;
print ctx "while( %s.hasNext() ) { var %s : %s = %s.next()" tmp (s_ident v.v_name) (type_str ctx v.v_type e.epos) tmp;
newline ctx;
gen_expr ctx e;
newline ctx;
spr ctx "}}";
handle_break();
| TTry (e,catchs) ->
spr ctx "try ";
gen_expr ctx e;
List.iter (fun (v,e) ->
newline ctx;
print ctx "catch( %s : %s )" (s_ident v.v_name) (type_str ctx v.v_type e.epos);
gen_expr ctx e;
) catchs;
| TSwitch (e,cases,def) ->
spr ctx "switch";
gen_value ctx (parent e);
spr ctx " {";
newline ctx;
List.iter (fun (el,e2) ->
List.iter (fun e ->
spr ctx "case ";
gen_value ctx e;
spr ctx ":";
) el;
gen_block ctx e2;
print ctx "break";
newline ctx;
) cases;
(match def with
| None -> ()
| Some e ->
spr ctx "default:";
gen_block ctx e;
print ctx "break";
newline ctx;
);
spr ctx "}"
| TCast (e1,None) ->
let s = type_str ctx e.etype e.epos in
if s = "*" then
gen_expr ctx e1
else begin
spr ctx "((";
gen_value ctx e1;
print ctx ") as %s)" s
end
| TCast (e1,Some t) ->
gen_expr ctx (Codegen.default_cast ctx.inf.com e1 t e.etype e.epos)
and gen_block_element ctx e = match e.eexpr with
| TObjectDecl fl ->
List.iter (fun (_,e) -> gen_block_element ctx e) fl
| _ ->
block_newline ctx;
gen_expr ctx e
and gen_block ctx e =
newline ctx;
match e.eexpr with
| TBlock [] -> ()
| _ ->
gen_expr ctx e;
newline ctx
and gen_value ctx e =
let assign e =
mk (TBinop (Ast.OpAssign,
mk (TLocal (match ctx.in_value with None -> assert false | Some r -> r)) t_dynamic e.epos,
e
)) e.etype e.epos
in
let block e =
mk (TBlock [e]) e.etype e.epos
in
let value block =
let old = ctx.in_value in
let t = type_str ctx e.etype e.epos in
let r = alloc_var (gen_local ctx "$r") e.etype in
ctx.in_value <- Some r;
if ctx.in_static then
print ctx "function() : %s " t
else
print ctx "(function($this:%s) : %s " (snd ctx.path) t;
let b = if block then begin
spr ctx "{";
let b = open_block ctx in
newline ctx;
print ctx "var %s : %s" r.v_name t;
newline ctx;
b
end else
(fun() -> ())
in
(fun() ->
if block then begin
newline ctx;
print ctx "return %s" r.v_name;
b();
newline ctx;
spr ctx "}";
end;
ctx.in_value <- old;
if ctx.in_static then
print ctx "()"
else
print ctx "(%s))" (this ctx)
)
in
match e.eexpr with
| TCall ({ eexpr = TLocal { v_name = "__keys__" } },_) | TCall ({ eexpr = TLocal { v_name = "__hkeys__" } },_) ->
let v = value true in
gen_expr ctx e;
v()
| TConst _
| TLocal _
| TArray _
| TBinop _
| TField _
| TEnumParameter _
| TTypeExpr _
| TParenthesis _
| TObjectDecl _
| TArrayDecl _
| TCall _
| TNew _
| TUnop _
| TFunction _ ->
gen_expr ctx e
| TMeta (_,e1) ->
gen_value ctx e1
| TCast (e1,None) ->
let s = type_str ctx e.etype e1.epos in
begin match s with
| "*" ->
gen_value ctx e1
| "Function" | "Array" | "String" ->
spr ctx "((";
gen_value ctx e1;
print ctx ") as %s)" s;
| _ ->
print ctx "%s(" s;
gen_value ctx e1;
spr ctx ")";
end
| TCast (e1,Some t) ->
gen_value ctx (Codegen.default_cast ctx.inf.com e1 t e.etype e.epos)
| TReturn _
| TBreak
| TContinue ->
unsupported e.epos
| TVar _
| TFor _
| TWhile _
| TThrow _ ->
(* value is discarded anyway *)
let v = value true in
gen_expr ctx e;
v()
| TBlock [] ->
spr ctx "null"
| TBlock [e] ->
gen_value ctx e
| TBlock el ->
let v = value true in
let rec loop = function
| [] ->
spr ctx "return null";
| [e] ->
gen_expr ctx (assign e);
| e :: l ->
gen_expr ctx e;
newline ctx;
loop l
in
loop el;
v();
| TIf (cond,e,eo) ->
spr ctx "(";
gen_value ctx cond;
spr ctx "?";
gen_value ctx e;
spr ctx ":";
(match eo with
| None -> spr ctx "null"
| Some e -> gen_value ctx e);
spr ctx ")"
| TSwitch (cond,cases,def) ->
let v = value true in
gen_expr ctx (mk (TSwitch (cond,
List.map (fun (e1,e2) -> (e1,assign e2)) cases,
match def with None -> None | Some e -> Some (assign e)
)) e.etype e.epos);
v()
| TTry (b,catchs) ->
let v = value true in
gen_expr ctx (mk (TTry (block (assign b),
List.map (fun (v,e) -> v, block (assign e)) catchs
)) e.etype e.epos);
v()
let final m =
if Ast.Meta.has Ast.Meta.Final m then "final " else ""
let generate_field ctx static f =
newline ctx;
ctx.in_static <- static;
ctx.gen_uid <- 0;
List.iter (fun(m,pl,_) ->
match m,pl with
| Ast.Meta.Meta, [Ast.ECall ((Ast.EConst (Ast.Ident n),_),args),_] ->
let mk_arg (a,p) =
match a with
| Ast.EConst (Ast.String s) -> (None, s)
| Ast.EBinop (Ast.OpAssign,(Ast.EConst (Ast.Ident n),_),(Ast.EConst (Ast.String s),_)) -> (Some n, s)
| _ -> error "Invalid meta definition" p
in
print ctx "[%s" n;
(match args with
| [] -> ()
| _ ->
print ctx "(";
concat ctx "," (fun a ->
match mk_arg a with
| None, s -> gen_constant ctx (snd a) (TString s)
| Some s, e -> print ctx "%s=" s; gen_constant ctx (snd a) (TString e)
) args;
print ctx ")");
print ctx "]";
| _ -> ()
) f.cf_meta;
let public = f.cf_public || Hashtbl.mem ctx.get_sets (f.cf_name,static) || (f.cf_name = "main" && static)
|| f.cf_name = "resolve" || Ast.Meta.has Ast.Meta.Public f.cf_meta
(* consider all abstract methods public to avoid issues with inlined private access *)
|| (match ctx.curclass.cl_kind with KAbstractImpl _ -> true | _ -> false)
in
let rights = (if static then "static " else "") ^ (if public then "public" else "protected") in
let p = ctx.curclass.cl_pos in
match f.cf_expr, f.cf_kind with
| Some { eexpr = TFunction fd }, Method (MethNormal | MethInline) ->
print ctx "%s%s " rights (if static then "" else final f.cf_meta);
let rec loop c =
match c.cl_super with
| None -> ()
| Some (c,_) ->
if PMap.mem f.cf_name c.cl_fields then
spr ctx "override "
else
loop c
in
if not static then loop ctx.curclass;
let h = gen_function_header ctx (Some (s_ident f.cf_name, f.cf_meta)) fd f.cf_params p in
gen_expr ctx fd.tf_expr;
h();
newline ctx
| _ ->
let is_getset = (match f.cf_kind with Var { v_read = AccCall } | Var { v_write = AccCall } -> true | _ -> false) in
if ctx.curclass.cl_interface then
match follow f.cf_type with
| TFun (args,r) when (match f.cf_kind with Method MethDynamic | Var _ -> false | _ -> true) ->
let rec loop = function
| [] -> f.cf_name
| (Ast.Meta.Getter,[Ast.EConst (Ast.String name),_],_) :: _ -> "get " ^ name
| (Ast.Meta.Setter,[Ast.EConst (Ast.String name),_],_) :: _ -> "set " ^ name
| _ :: l -> loop l
in
print ctx "function %s(" (loop f.cf_meta);
concat ctx "," (fun (arg,o,t) ->
let tstr = type_str ctx t p in
print ctx "%s : %s" arg tstr;
if o then print ctx " = %s" (default_value tstr);
) args;
print ctx ") : %s " (type_str ctx r p);
| _ -> ()
else
let gen_init () = match f.cf_expr with
| None -> ()
| Some e ->
print ctx " = ";
gen_value ctx e
in
if is_getset then begin
let t = type_str ctx f.cf_type p in
let id = s_ident f.cf_name in
let v = (match f.cf_kind with Var v -> v | _ -> assert false) in
(match v.v_read with
| AccNormal | AccNo | AccNever ->
print ctx "%s function get %s() : %s { return $%s; }" rights id t id;
newline ctx
| AccCall ->
print ctx "%s function get %s() : %s { return %s(); }" rights id t ("get_" ^ f.cf_name);
newline ctx
| _ -> ());
(match v.v_write with
| AccNormal | AccNo | AccNever ->
print ctx "%s function set %s( __v : %s ) : void { $%s = __v; }" rights id t id;
newline ctx
| AccCall ->
print ctx "%s function set %s( __v : %s ) : void { %s(__v); }" rights id t ("set_" ^ f.cf_name);
newline ctx
| _ -> ());
print ctx "%sprotected var $%s : %s" (if static then "static " else "") (s_ident f.cf_name) (type_str ctx f.cf_type p);
gen_init()
end else begin
print ctx "%s var %s : %s" rights (s_ident f.cf_name) (type_str ctx f.cf_type p);
gen_init()
end
let rec define_getset ctx stat c =
let def f name =
Hashtbl.add ctx.get_sets (name,stat) f.cf_name
in
let field f =
match f.cf_kind with
| Method _ -> ()
| Var v ->
(match v.v_read with AccCall -> def f ("get_" ^ f.cf_name) | _ -> ());
(match v.v_write with AccCall -> def f ("set_" ^ f.cf_name) | _ -> ())
in
List.iter field (if stat then c.cl_ordered_statics else c.cl_ordered_fields);
match c.cl_super with
| Some (c,_) when not stat -> define_getset ctx stat c
| _ -> ()
let generate_class ctx c =
ctx.curclass <- c;
define_getset ctx true c;
define_getset ctx false c;
ctx.local_types <- List.map snd c.cl_params;
let pack = open_block ctx in
print ctx "\tpublic %s%s%s %s " (final c.cl_meta) (match c.cl_dynamic with None -> "" | Some _ -> if c.cl_interface then "" else "dynamic ") (if c.cl_interface then "interface" else "class") (snd c.cl_path);
(match c.cl_super with
| None -> ()
| Some (csup,_) -> print ctx "extends %s " (s_path ctx true csup.cl_path c.cl_pos));
(match c.cl_implements with
| [] -> ()
| l ->
spr ctx (if c.cl_interface then "extends " else "implements ");
concat ctx ", " (fun (i,_) -> print ctx "%s" (s_path ctx true i.cl_path c.cl_pos)) l);
spr ctx "{";
let cl = open_block ctx in
(match c.cl_constructor with
| None -> ()
| Some f ->
let f = { f with
cf_name = snd c.cl_path;
cf_public = true;
cf_kind = Method MethNormal;
} in
ctx.constructor_block <- true;
generate_field ctx false f;
);
List.iter (generate_field ctx false) c.cl_ordered_fields;
List.iter (generate_field ctx true) c.cl_ordered_statics;
cl();
newline ctx;
print ctx "}";
pack();
newline ctx;
print ctx "}";
newline ctx
let generate_main ctx inits =
ctx.curclass <- { null_class with cl_path = [],"__main__" };
let pack = open_block ctx in
print ctx "\timport flash.Lib";
newline ctx;
print ctx "public class __main__ extends %s {" (s_path ctx true (["flash"],"Boot") Ast.null_pos);
let cl = open_block ctx in
newline ctx;
spr ctx "public function __main__() {";
let fl = open_block ctx in
newline ctx;
spr ctx "super()";
newline ctx;
spr ctx "flash.Lib.current = this";
List.iter (fun e -> newline ctx; gen_expr ctx e) inits;
fl();
newline ctx;
print ctx "}";
cl();
newline ctx;
print ctx "}";
pack();
newline ctx;
print ctx "}";
newline ctx
let generate_enum ctx e =
ctx.local_types <- List.map snd e.e_params;
let pack = open_block ctx in
let ename = snd e.e_path in
print ctx "\tpublic final class %s extends enum {" ename;
let cl = open_block ctx in
newline ctx;
print ctx "public static const __isenum : Boolean = true";
newline ctx;
print ctx "public function %s( t : String, index : int, p : Array = null ) : void { this.tag = t; this.index = index; this.params = p; }" ename;
PMap.iter (fun _ c ->
newline ctx;
match c.ef_type with
| TFun (args,_) ->
print ctx "public static function %s(" c.ef_name;
concat ctx ", " (fun (a,o,t) ->
print ctx "%s : %s" (s_ident a) (type_str ctx t c.ef_pos);
if o then spr ctx " = null";
) args;
print ctx ") : %s {" ename;
print ctx " return new %s(\"%s\",%d,[" ename c.ef_name c.ef_index;
concat ctx "," (fun (a,_,_) -> spr ctx (s_ident a)) args;
print ctx "]); }";
| _ ->
print ctx "public static var %s : %s = new %s(\"%s\",%d)" c.ef_name ename ename c.ef_name c.ef_index;
) e.e_constrs;
newline ctx;
(match Codegen.build_metadata ctx.inf.com (TEnumDecl e) with
| None -> ()
| Some e ->
print ctx "public static var __meta__ : * = ";
gen_expr ctx e;
newline ctx);
print ctx "public static var __constructs__ : Array = [%s];" (String.concat "," (List.map (fun s -> "\"" ^ Ast.s_escape s ^ "\"") e.e_names));
cl();
newline ctx;
print ctx "}";
pack();
newline ctx;
print ctx "}";
newline ctx
let generate_base_enum ctx =
let pack = open_block ctx in
spr ctx "\timport flash.Boot";
newline ctx;
spr ctx "public class enum {";
let cl = open_block ctx in
newline ctx;
spr ctx "public var tag : String";
newline ctx;
spr ctx "public var index : int";
newline ctx;
spr ctx "public var params : Array";
newline ctx;
spr ctx "public function toString() : String { return flash.Boot.enum_to_string(this); }";
cl();
newline ctx;
print ctx "}";
pack();
newline ctx;
print ctx "}";
newline ctx
let generate com =
let infos = {
com = com;
} in
generate_resources infos;
let ctx = init infos ([],"enum") in
generate_base_enum ctx;
close ctx;
let inits = ref [] in
List.iter (fun t ->
match t with
| TClassDecl c ->
let c = (match c.cl_path with
| ["flash"],"FlashXml__" -> { c with cl_path = [],"Xml" }
| (pack,name) -> { c with cl_path = (pack,protect name) }
) in
(match c.cl_init with
| None -> ()
| Some e -> inits := e :: !inits);
if c.cl_extern then
()
else
let ctx = init infos c.cl_path in
generate_class ctx c;
close ctx
| TEnumDecl e ->
let pack,name = e.e_path in
let e = { e with e_path = (pack,protect name) } in
if e.e_extern then
()
else
let ctx = init infos e.e_path in
generate_enum ctx e;
close ctx
| TTypeDecl _ | TAbstractDecl _ ->
()
) com.types;
(match com.main with
| None -> ()
| Some e -> inits := e :: !inits);
let ctx = init infos ([],"__main__") in
generate_main ctx (List.rev !inits);
close ctx
haxe_3.2.1+dfsg.orig/gencommon.ml 0000664 0001750 0001750 00001471010 12607337712 016644 0 ustar andy andy 0000000 0000000 (*
* Copyright (C)2005-2013 Haxe Foundation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*)
(*
Gen Common API
This module intends to be a common set of utilities common to all targets.
It's intended to provide a set of tools to be able to make targets in Haxe more easily, and to
allow the programmer to have more control of how the target language will handle the program.
For example, as of now, the hxcpp target, while greatly done, relies heavily on cpp's own operator
overloading, and implicit conversions, which make it very hard to deliver a similar solution for languages
that lack these features.
So this little framework is here so you can manipulate the Haxe AST and start bringing the AST closer
to how it's intenteded to be in your host language.
Rules
Design goals
Naming convention
Weaknesses and TODO's
*)
open Unix
open Ast
open Type
open Common
open Option
open Printf
open ExtString
let debug_type_ctor = function
| TMono _ -> "TMono"
| TEnum _ -> "TEnum"
| TInst _ -> "TInst"
| TType _ -> "TType"
| TFun _ -> "TFun"
| TAnon _ -> "TAnon"
| TDynamic _ -> "TDynamic"
| TLazy _ -> "TLazy"
| TAbstract _ -> "TAbstract"
let debug_type = (s_type (print_context()))
let debug_expr = s_expr debug_type
let rec like_float t =
match follow t with
| TAbstract({ a_path = ([], "Float") },[])
| TAbstract({ a_path = ([], "Int") },[]) -> true
| TAbstract({ a_path = (["cs"], "Pointer") },_) -> false
| TAbstract(a, _) -> List.exists (fun t -> like_float t) a.a_from || List.exists (fun t -> like_float t) a.a_to
| _ -> false
let rec like_int t =
match follow t with
| TAbstract({ a_path = ([], "Int") },[]) -> true
| TAbstract({ a_path = (["cs"], "Pointer") },_) -> false
| TAbstract(a, _) -> List.exists (fun t -> like_int t) a.a_from || List.exists (fun t -> like_int t) a.a_to
| _ -> false
let rec like_i64 t =
match follow t with
| TInst({ cl_path = (["cs"], "Int64") },[])
| TAbstract({ a_path = (["cs"], "Int64") },[])
| TInst({ cl_path = (["cs"], "UInt64") },[])
| TInst({ cl_path = (["java"], "Int64") },[])
| TAbstract({ a_path = (["java"], "Int64") },[])
| TInst({ cl_path = (["haxe"], "Int64") },[])
| TAbstract({ a_path = (["haxe"], "Int64") },[]) -> true
| TAbstract(a, _) -> List.exists (fun t -> like_i64 t) a.a_from || List.exists (fun t -> like_i64 t) a.a_to
| _ -> false
let follow_once t =
match t with
| TMono r ->
(match !r with
| Some t -> t
| _ -> t_dynamic (* avoid infinite loop / should be the same in this context *))
| TLazy f ->
!f()
| TType (t,tl) ->
apply_params t.t_params tl t.t_type
| _ -> t
let t_empty = TAnon({ a_fields = PMap.empty; a_status = ref (Closed) })
let tmp_count = ref 0
let reset_temps () = tmp_count := 0
(* the undefined is a special var that works like null, but can have special meaning *)
let v_undefined = alloc_var "__undefined__" t_dynamic
let undefined pos = { eexpr = TLocal(v_undefined); etype = t_dynamic; epos = pos }
module ExprHashtblHelper =
struct
type hash_texpr_t =
{
hepos : pos;
heexpr : int;
hetype : int;
}
let mk_heexpr = function
| TConst _ -> 0 | TLocal _ -> 1 | TArray _ -> 3 | TBinop _ -> 4 | TField _ -> 5 | TTypeExpr _ -> 7 | TParenthesis _ -> 8 | TObjectDecl _ -> 9
| TArrayDecl _ -> 10 | TCall _ -> 11 | TNew _ -> 12 | TUnop _ -> 13 | TFunction _ -> 14 | TVar _ -> 15 | TBlock _ -> 16 | TFor _ -> 17 | TIf _ -> 18 | TWhile _ -> 19
| TSwitch _ -> 20 (* | TPatMatch _ -> 21 *) | TTry _ -> 22 | TReturn _ -> 23 | TBreak -> 24 | TContinue -> 25 | TThrow _ -> 26 | TCast _ -> 27 | TMeta _ -> 28 | TEnumParameter _ -> 29
let mk_heetype = function
| TMono _ -> 0 | TEnum _ -> 1 | TInst _ -> 2 | TType _ -> 3 | TFun _ -> 4
| TAnon _ -> 5 | TDynamic _ -> 6 | TLazy _ -> 7 | TAbstract _ -> 8
let mk_type e =
{
hepos = e.epos;
heexpr = mk_heexpr e.eexpr;
hetype = mk_heetype e.etype;
}
end;;
let path_of_md_def md_def =
match md_def.m_types with
| [TClassDecl c] -> c.cl_path
| _ -> md_def.m_path
open ExprHashtblHelper;;
(* Expression Hashtbl. This shouldn't be kept indefinately as it's not a weak Hashtbl. *)
module ExprHashtbl = Hashtbl.Make(
struct
type t = Type.texpr
let equal = (==)
let hash t = Hashtbl.hash (mk_type t)
end
);;
(* ******************************************* *)
(* Gen Common
This is the key module for generation of Java and C# sources
In order for both modules to share as much code as possible, some
rules were devised:
- every feature has its own submodule, and may contain the following methods:
- configure
sets all the configuration variables for the module to run. If a module has this method,
it *should* be called once before running any filter
- run_filter ->
runs the filter immediately on the context
- add_filter ->
adds the filter to an expr->expr list. Most filter modules will provide this option so the filter
function can only run once.
- most submodules will have side-effects so the order of operations will matter.
When running configure / add_filter this might be taken care of with the rule-based dispatch system working
underneath, but still there might be some incompatibilities. There will be an effort to document it.
The modules can hint on the order by suffixing their functions with _first or _last.
- any of those methods might have different parameters, that configure how the filter will run.
For example, a simple filter that maps switch() expressions to if () .. else if... might receive
a function that filters what content should be mapped
- Other targets can use those filters on their own code. In order to do that,
a simple configuration step is needed: you need to initialize a generator_ctx type with
Gencommon.new_gen (context:Common.context)
with a generator_ctx context you will be able to add filters to your code, and execute them with
Gencommon.run_filters (gen_context:Gencommon.generator_ctx)
After running the filters, you can run your own generator normally.
(* , or you can run
Gencommon.generate_modules (gen_context:Gencommon.generator_ctx) (extension:string) (module_gen:module_type list->bool)
where module_gen will take a whole module (can be *)
*)
(* ******************************************* *)
(* common helpers *)
(* ******************************************* *)
let assertions = false (* when assertions == true, many assertions will be made to guarantee the quality of the data input *)
let debug_mode = ref false
let trace s = if !debug_mode then print_endline s else ()
let timer name = if !debug_mode then Common.timer name else fun () -> ()
let is_string t = match follow t with | TInst({ cl_path = ([], "String") }, []) -> true | _ -> false
(* helper function for creating Anon types of class / enum modules *)
let anon_of_classtype cl =
TAnon {
a_fields = cl.cl_statics;
a_status = ref (Statics cl)
}
let anon_of_enum e =
TAnon {
a_fields = PMap.empty;
a_status = ref (EnumStatics e)
}
let anon_of_abstract a =
TAnon {
a_fields = PMap.empty;
a_status = ref (AbstractStatics a)
}
let anon_of_mt mt = match mt with
| TClassDecl cl -> anon_of_classtype cl
| TEnumDecl e -> anon_of_enum e
| TAbstractDecl a -> anon_of_abstract a
| _ -> assert false
let anon_class t =
match follow t with
| TAnon anon ->
(match !(anon.a_status) with
| Statics (cl) -> Some(TClassDecl(cl))
| EnumStatics (e) -> Some(TEnumDecl(e))
| AbstractStatics (a) -> Some(TAbstractDecl(a))
| _ -> None)
| _ -> None
let path_s path =
match path with | ([], s) -> s | (p, s) -> (String.concat "." (fst path)) ^ "." ^ (snd path)
let rec t_to_md t = match t with
| TInst (cl,_) -> TClassDecl cl
| TEnum (e,_) -> TEnumDecl e
| TType (t,_) -> TTypeDecl t
| TAbstract (a,_) -> TAbstractDecl a
| TAnon anon ->
(match !(anon.a_status) with
| EnumStatics e -> TEnumDecl e
| Statics cl -> TClassDecl cl
| AbstractStatics a -> TAbstractDecl a
| _ -> assert false)
| TLazy f -> t_to_md (!f())
| TMono r -> (match !r with | Some t -> t_to_md t | None -> assert false)
| _ -> assert false
let get_cl mt = match mt with | TClassDecl cl -> cl | _ -> failwith ("Unexpected module type of '" ^ path_s (t_path mt) ^ "'")
let get_abstract mt = match mt with | TAbstractDecl a -> a | _ -> failwith ("Unexpected module type of '" ^ path_s (t_path mt) ^ "'")
let get_tdef mt = match mt with | TTypeDecl t -> t | _ -> assert false
let mk_mt_access mt pos = { eexpr = TTypeExpr(mt); etype = anon_of_mt mt; epos = pos }
let is_void t = match follow t with
| TAbstract ({ a_path = ([], "Void") },[]) ->
true
| _ -> false
let mk_local var pos = { eexpr = TLocal(var); etype = var.v_type; epos = pos }
(* this function is used by CastDetection module *)
let get_fun t =
match follow t with | TFun(r1,r2) -> (r1,r2) | _ -> (trace (s_type (print_context()) (follow t) )); assert false
let mk_cast t e =
{ eexpr = TCast(e, None); etype = t; epos = e.epos }
let mk_classtype_access cl pos =
{ eexpr = TTypeExpr(TClassDecl(cl)); etype = anon_of_classtype cl; epos = pos }
let mk_static_field_access_infer cl field pos params =
try
let cf = (PMap.find field cl.cl_statics) in
{ eexpr = TField(mk_classtype_access cl pos, FStatic(cl, cf)); etype = (if params = [] then cf.cf_type else apply_params cf.cf_params params cf.cf_type); epos = pos }
with | Not_found -> failwith ("Cannot find field " ^ field ^ " in type " ^ (path_s cl.cl_path))
let mk_static_field_access cl field fieldt pos =
{ (mk_static_field_access_infer cl field pos []) with etype = fieldt }
(* stolen from Hugh's sources ;-) *)
(* this used to be a class, but there was something in there that crashed ocaml native compiler in windows *)
module SourceWriter =
struct
type source_writer =
{
sw_buf : Buffer.t;
mutable sw_has_content : bool;
mutable sw_indent : string;
mutable sw_indents : string list;
}
let new_source_writer () =
{
sw_buf = Buffer.create 0;
sw_has_content = false;
sw_indent = "";
sw_indents = [];
}
let add_writer w_write w_read = Buffer.add_buffer w_read.sw_buf w_write.sw_buf
let contents w = Buffer.contents w.sw_buf
let len w = Buffer.length w.sw_buf
let write w x =
(if not w.sw_has_content then begin w.sw_has_content <- true; Buffer.add_string w.sw_buf w.sw_indent; Buffer.add_string w.sw_buf x; end else Buffer.add_string w.sw_buf x);
let len = (String.length x)-1 in
if len >= 0 && String.get x len = '\n' then begin w.sw_has_content <- false end else w.sw_has_content <- true
let push_indent w = w.sw_indents <- "\t"::w.sw_indents; w.sw_indent <- String.concat "" w.sw_indents
let pop_indent w =
match w.sw_indents with
| h::tail -> w.sw_indents <- tail; w.sw_indent <- String.concat "" w.sw_indents
| [] -> w.sw_indent <- "/*?*/"
let newline w = write w "\n"
let begin_block w = (if w.sw_has_content then newline w); write w "{"; push_indent w; newline w
let end_block w = pop_indent w; (if w.sw_has_content then newline w); write w "}"; newline w
let print w =
(if not w.sw_has_content then begin w.sw_has_content <- true; Buffer.add_string w.sw_buf w.sw_indent end);
bprintf w.sw_buf;
end;;
(* rule_dispatcher's priority *)
type priority =
| PFirst
| PLast
| PZero
| PCustom of float
exception DuplicateName of string
exception NoRulesApplied
let indent = ref []
(* the rule dispatcher is the primary way to deal with distributed "plugins" *)
(* we will define rules that will form a distributed / extensible match system *)
class ['tp, 'ret] rule_dispatcher name ignore_not_found =
object(self)
val tbl = Hashtbl.create 16
val mutable keys = []
val names = Hashtbl.create 16
val mutable temp = 0
method add ?(name : string option) (* name helps debugging *) ?(priority : priority = PZero) (rule : 'tp->'ret option) =
let p = match priority with
| PFirst -> infinity
| PLast -> neg_infinity
| PZero -> 0.0
| PCustom i -> i
in
let q = if not( Hashtbl.mem tbl p ) then begin
let q = Stack.create() in
Hashtbl.add tbl p q;
keys <- p :: keys;
keys <- List.sort (fun x y -> - (compare x y)) keys;
q
end else Hashtbl.find tbl p in
let name = match name with
| None -> temp <- temp + 1; "$_" ^ (string_of_int temp)
| Some s -> s
in
(if Hashtbl.mem names name then raise (DuplicateName(name)));
Hashtbl.add names name q;
Stack.push (name, rule) q
method describe =
Hashtbl.iter (fun s _ -> (trace s)) names;
method remove (name : string) =
if Hashtbl.mem names name then begin
let q = Hashtbl.find names name in
let q_temp = Stack.create () in
Stack.iter (function
| (n, _) when n = name -> ()
| _ as r -> Stack.push r q_temp
) q;
Stack.clear q;
Stack.iter (fun r -> Stack.push r q) q_temp;
Hashtbl.remove names name;
true
end else false
method run_f tp = get (self#run tp)
method did_run tp = is_some (self#run tp)
method get_list =
let ret = ref [] in
List.iter (fun key ->
let q = Hashtbl.find tbl key in
Stack.iter (fun (_, rule) -> ret := rule :: !ret) q
) keys;
List.rev !ret
method run_from (priority:float) (tp:'tp) : 'ret option =
let ok = ref ignore_not_found in
let ret = ref None in
indent := "\t" :: !indent;
(try begin
List.iter (fun key ->
if key < priority then begin
let q = Hashtbl.find tbl key in
Stack.iter (fun (n, rule) ->
let t = if !debug_mode then Common.timer ("rule dispatcher rule: " ^ n) else fun () -> () in
let r = rule(tp) in
t();
if is_some r then begin ret := r; raise Exit end
) q
end
) keys
end with Exit -> ok := true);
(match !indent with
| [] -> ()
| h::t -> indent := t);
(if not (!ok) then raise NoRulesApplied);
!ret
method run (tp:'tp) : 'ret option =
self#run_from infinity tp
end;;
(* this is a special case where tp = tret and you stack their output as the next's input *)
class ['tp] rule_map_dispatcher name =
object(self)
inherit ['tp, 'tp] rule_dispatcher name true as super
method run_f tp = get (self#run tp)
method run_from (priority:float) (tp:'tp) : 'ret option =
let cur = ref tp in
(try begin
List.iter (fun key ->
if key < priority then begin
let q = Hashtbl.find tbl key in
Stack.iter (fun (n, rule) ->
trace ("running rule " ^ n);
let t = if !debug_mode then Common.timer ("rule map dispatcher rule: " ^ n) else fun () -> () in
let r = rule(!cur) in
t();
if is_some r then begin cur := get r end
) q
end
) keys
end with Exit -> ());
Some (!cur)
end;;
type generator_ctx =
{
(* these are the basic context fields. If another target is using this context, *)
(* this is all you need to care about *)
mutable gcon : Common.context;
gclasses : gen_classes;
gtools : gen_tools;
(*
configurable function that receives a desired name and makes it "internal", doing the best
to ensure that it will not be called from outside.
To avoid name clashes between internal names, user must specify two strings: a "namespace" and the name itself
*)
mutable gmk_internal_name : string->string->string;
(*
module filters run before module filters and they should generate valid haxe syntax as a result.
Module filters shouldn't go through the expressions as it adds an unnecessary burden to the GC,
and it can all be done in a single step with gexpr_filters and proper priority selection.
As a convention, Module filters should end their name with Modf, so they aren't mistaken with expression filters
*)
gmodule_filters : (module_type) rule_map_dispatcher;
(*
expression filters are the most common filters to be applied.
They should also generate only valid haxe expressions, so e.g. calls to non-existant methods
should be avoided, although there are some ways around them (like gspecial_methods)
*)
gexpr_filters : (texpr) rule_map_dispatcher;
(*
syntax filters are also expression filters but they no longer require
that the resulting expressions be valid haxe expressions.
They then have no guarantee that either the input expressions or the output one follow the same
rules as normal haxe code.
*)
gsyntax_filters : (texpr) rule_map_dispatcher;
(* these are more advanced features, but they would require a rewrite of targets *)
(* they are just helpers to ditribute functions like "follow" or "type to string" *)
(* so adding a module will already take care of correctly following a certain type of *)
(* variable, for example *)
(* follows the type through typedefs, lazy typing, etc. *)
(* it's the place to put specific rules to handle typedefs, like *)
(* other basic types like UInt *)
gfollow : (t, t) rule_dispatcher;
gtypes : (path, module_type) Hashtbl.t;
mutable gtypes_list : module_type list;
mutable gmodules : Type.module_def list;
(* cast detection helpers / settings *)
(* this is a cache for all field access types *)
greal_field_types : (path * string, (tclass_field (* does the cf exist *) * t (*cf's type in relation to current class type params *) * t * tclass (* declared class *) ) option) Hashtbl.t;
(* this function allows any code to handle casts as if it were inside the cast_detect module *)
mutable ghandle_cast : t->t->texpr->texpr;
(* when an unsafe cast is made, we can warn the user *)
mutable gon_unsafe_cast : t->t->pos->unit;
(* does this type needs to be boxed? Normally always false, unless special type handling must be made *)
mutable gneeds_box : t->bool;
(* does this 'special type' needs cast to this other type? *)
(* this is here so we can implement custom behavior for "opaque" typedefs *)
mutable gspecial_needs_cast : t->t->bool;
(* sometimes we may want to support unrelated conversions on cast detection *)
(* for example, haxe.lang.Null -> T on C# *)
(* every time an unrelated conversion is found, each to/from path is searched on this hashtbl *)
(* if found, the function will be executed with from_type, to_type. If returns true, it means that *)
(* it is a supported conversion, and the unsafe cast routine changes to a simple cast *)
gsupported_conversions : (path, t->t->bool) Hashtbl.t;
(* API for filters *)
(* add type can be called at any time, and will add a new module_def that may or may not be filtered *)
(* module_type -> should_filter *)
mutable gadd_type : module_type -> bool -> unit;
(* during expr filters, add_to_module will be available so module_types can be added to current module_def. we must pass the priority argument so the filters can be resumed *)
mutable gadd_to_module : module_type -> float -> unit;
(* during expr filters, shows the current class path *)
mutable gcurrent_path : path;
(* current class *)
mutable gcurrent_class : tclass option;
(* current class field, if any *)
mutable gcurrent_classfield : tclass_field option;
(* events *)
(* is executed once every new classfield *)
mutable gon_classfield_start : (unit -> unit) list;
(* is executed once every new module type *)
mutable gon_new_module_type : (unit -> unit) list;
(* after module filters ended *)
mutable gafter_mod_filters_ended : (unit -> unit) list;
(* after expression filters ended *)
mutable gafter_expr_filters_ended : (unit -> unit) list;
(* after all filters are run *)
mutable gafter_filters_ended : (unit -> unit) list;
mutable gbase_class_fields : (string, tclass_field) PMap.t;
(* real type is the type as it is read by the target. *)
(* This function is here because most targets don't have *)
(* a 1:1 translation between haxe types and its native types *)
(* But types aren't changed to this representation as we might lose *)
(* some valuable type information in the process *)
mutable greal_type : t -> t;
(*
the same as greal_type but for type parameters.
*)
mutable greal_type_param : module_type -> tparams -> tparams;
(*
is the type a value type?
This may be used in some optimizations where reference types and value types
are handled differently. At first the default is very good to use, and if tweaks are needed,
it's best to be done by adding @:struct meta to the value types
*
mutable gis_value_type : t -> bool;*)
(* misc configuration *)
(*
Should the target allow type parameter dynamic conversion,
or should we add a cast to those cases as well?
*)
mutable gallow_tp_dynamic_conversion : bool;
(*
Does the target support type parameter constraints?
If not, they will be ignored when detecting casts
*)
mutable guse_tp_constraints : bool;
(* internal apis *)
(* param_func_call : used by TypeParams and CastDetection *)
mutable gparam_func_call : texpr->texpr->tparams->texpr list->texpr;
(* does it already have a type parameter cast handler? This is used by CastDetect to know if it should handle type parameter casts *)
mutable ghas_tparam_cast_handler : bool;
(* type parameter casts - special cases *)
(* function cast_from, cast_to -> texpr *)
gtparam_cast : (path, (texpr->t->texpr)) Hashtbl.t;
(*
special vars are used for adding special behavior to
*)
gspecial_vars : (string, bool) Hashtbl.t;
}
and gen_classes =
{
cl_reflect : tclass;
cl_type : tclass;
cl_dyn : tclass;
t_iterator : tdef;
mutable nativearray_len : texpr -> pos -> texpr;
mutable nativearray_type : Type.t -> Type.t;
mutable nativearray : Type.t -> Type.t;
}
(* add here all reflection transformation additions *)
and gen_tools =
{
(* (klass : texpr, t : t) : texpr *)
mutable r_create_empty : texpr->t->texpr;
(* Reflect.fields(). The bool is if we are iterating in a read-only manner. If it is read-only we might not need to allocate a new array *)
mutable r_fields : bool->texpr->texpr;
(* (first argument = return type. should be void in most cases) Reflect.setField(obj, field, val) *)
mutable r_set_field : t->texpr->texpr->texpr->texpr;
(* Reflect.field. bool indicates if is safe (no error throwing) or unsafe; t is the expected return type true = safe *)
mutable r_field : bool->t->texpr->texpr->texpr;
(*
these are now the functions that will later be used when creating the reflection classes
*)
(* on the default implementation (at OverloadingCtors), it will be new SomeClass(EmptyInstance) *)
mutable rf_create_empty : tclass->tparams->pos->texpr;
}
let get_type types path =
List.find (fun md -> match md with
| TClassDecl cl when cl.cl_path = path -> true
| TEnumDecl e when e.e_path = path -> true
| TTypeDecl t when t.t_path = path -> true
| TAbstractDecl a when a.a_path = path -> true
| _ -> false
) types
let new_ctx con =
let types = Hashtbl.create (List.length con.types) in
List.iter (fun mt ->
match mt with
| TClassDecl cl -> Hashtbl.add types cl.cl_path mt
| TEnumDecl e -> Hashtbl.add types e.e_path mt
| TTypeDecl t -> Hashtbl.add types t.t_path mt
| TAbstractDecl a -> Hashtbl.add types a.a_path mt
) con.types;
let cl_dyn = match get_type con.types ([], "Dynamic") with
| TClassDecl c -> c
| TAbstractDecl a ->
mk_class a.a_module ([], "Dynamic") a.a_pos
| _ -> assert false
in
let rec gen = {
gcon = con;
gclasses = {
cl_reflect = get_cl (get_type con.types ([], "Reflect"));
cl_type = get_cl (get_type con.types ([], "Type"));
cl_dyn = cl_dyn;
t_iterator = get_tdef (get_type con.types ([], "Iterator"));
nativearray = (fun _ -> assert false);
nativearray_type = (fun _ -> assert false);
nativearray_len = (fun _ -> assert false);
};
gtools = {
r_create_empty = (fun eclass t ->
let fieldcall = mk_static_field_access_infer gen.gclasses.cl_type "createEmptyInstance" eclass.epos [t] in
{ eexpr = TCall(fieldcall, [eclass]); etype = t; epos = eclass.epos }
);
r_fields = (fun is_used_only_by_iteration expr ->
let fieldcall = mk_static_field_access_infer gen.gclasses.cl_reflect "fields" expr.epos [] in
{ eexpr = TCall(fieldcall, [expr]); etype = gen.gcon.basic.tarray gen.gcon.basic.tstring; epos = expr.epos }
);
(* Reflect.setField(obj, field, val). t by now is ignored. FIXME : fix this implementation *)
r_set_field = (fun t obj field v ->
let fieldcall = mk_static_field_access_infer gen.gclasses.cl_reflect "setField" v.epos [] in
{ eexpr = TCall(fieldcall, [obj; field; v]); etype = t_dynamic; epos = v.epos }
);
(* Reflect.field. bool indicates if is safe (no error throwing) or unsafe. true = safe *)
r_field = (fun is_safe t obj field ->
let fieldcall = mk_static_field_access_infer gen.gclasses.cl_reflect "field" obj.epos [] in
(* FIXME: should we see if needs to cast? *)
mk_cast t { eexpr = TCall(fieldcall, [obj; field]); etype = t_dynamic; epos = obj.epos }
);
rf_create_empty = (fun cl p pos ->
gen.gtools.r_create_empty { eexpr = TTypeExpr(TClassDecl cl); epos = pos; etype = t_dynamic } (TInst(cl,p))
); (* TODO: Maybe implement using normal reflection? Type.createEmpty(MyClass) *)
};
gmk_internal_name = (fun ns s -> sprintf "__%s_%s" ns s);
gexpr_filters = new rule_map_dispatcher "gexpr_filters";
gmodule_filters = new rule_map_dispatcher "gmodule_filters";
gsyntax_filters = new rule_map_dispatcher "gsyntax_filters";
gfollow = new rule_dispatcher "gfollow" false;
gtypes = types;
gtypes_list = con.types;
gmodules = con.modules;
greal_field_types = Hashtbl.create 0;
ghandle_cast = (fun to_t from_t e -> mk_cast to_t e);
gon_unsafe_cast = (fun t t2 pos -> (gen.gcon.warning ("Type " ^ (debug_type t2) ^ " is being cast to the unrelated type " ^ (s_type (print_context()) t)) pos));
gneeds_box = (fun t -> false);
gspecial_needs_cast = (fun to_t from_t -> true);
gsupported_conversions = Hashtbl.create 0;
gadd_type = (fun md should_filter ->
if should_filter then begin
gen.gtypes_list <- md :: gen.gtypes_list;
gen.gmodules <- { m_id = alloc_mid(); m_path = (t_path md); m_types = [md]; m_extra = module_extra "" "" 0. MFake } :: gen.gmodules;
Hashtbl.add gen.gtypes (t_path md) md;
end else gen.gafter_filters_ended <- (fun () ->
gen.gtypes_list <- md :: gen.gtypes_list;
gen.gmodules <- { m_id = alloc_mid(); m_path = (t_path md); m_types = [md]; m_extra = module_extra "" "" 0. MFake } :: gen.gmodules;
Hashtbl.add gen.gtypes (t_path md) md;
) :: gen.gafter_filters_ended;
);
gadd_to_module = (fun md pr -> failwith "module added outside expr filters");
gcurrent_path = ([],"");
gcurrent_class = None;
gcurrent_classfield = None;
gon_classfield_start = [];
gon_new_module_type = [];
gafter_mod_filters_ended = [];
gafter_expr_filters_ended = [];
gafter_filters_ended = [];
gbase_class_fields = PMap.empty;
greal_type = (fun t -> t);
greal_type_param = (fun _ t -> t);
gallow_tp_dynamic_conversion = false;
guse_tp_constraints = false;
(* as a default, ignore the params *)
gparam_func_call = (fun ecall efield params elist -> { ecall with eexpr = TCall(efield, elist) });
ghas_tparam_cast_handler = false;
gtparam_cast = Hashtbl.create 0;
gspecial_vars = Hashtbl.create 0;
} in
(*gen.gtools.r_create_empty <-
gen.gtools.r_get_class <-
gen.gtools.r_fields <- *)
gen
let init_ctx gen =
(* ultimately add a follow once handler as the last follow handler *)
let follow_f = gen.gfollow#run in
let follow t =
match t with
| TMono r ->
(match !r with
| Some t -> follow_f t
| _ -> Some t)
| TLazy f ->
follow_f (!f())
| TType (t,tl) ->
follow_f (apply_params t.t_params tl t.t_type)
| _ -> Some t
in
gen.gfollow#add ~name:"final" ~priority:PLast follow
(* run_follow (gen:generator_ctx) (t:t) *)
let run_follow gen = gen.gfollow#run_f
let reorder_modules gen =
let modules = Hashtbl.create 20 in
List.iter (fun md ->
Hashtbl.add modules ( (t_infos md).mt_module ).m_path md
) gen.gtypes_list;
gen.gmodules <- [];
let processed = Hashtbl.create 20 in
Hashtbl.iter (fun md_path md ->
if not (Hashtbl.mem processed md_path) then begin
Hashtbl.add processed md_path true;
gen.gmodules <- { m_id = alloc_mid(); m_path = md_path; m_types = List.rev ( Hashtbl.find_all modules md_path ); m_extra = (t_infos md).mt_module.m_extra } :: gen.gmodules
end
) modules
let run_filters_from gen t filters =
match t with
| TClassDecl c ->
trace (snd c.cl_path);
gen.gcurrent_path <- c.cl_path;
gen.gcurrent_class <- Some(c);
List.iter (fun fn -> fn()) gen.gon_new_module_type;
gen.gcurrent_classfield <- None;
let rec process_field f =
reset_temps();
gen.gcurrent_classfield <- Some(f);
List.iter (fun fn -> fn()) gen.gon_classfield_start;
trace f.cf_name;
(match f.cf_expr with
| None -> ()
| Some e ->
f.cf_expr <- Some (List.fold_left (fun e f -> f e) e filters));
List.iter process_field f.cf_overloads;
in
List.iter process_field c.cl_ordered_fields;
List.iter process_field c.cl_ordered_statics;
(match c.cl_constructor with
| None -> ()
| Some f -> process_field f);
gen.gcurrent_classfield <- None;
(match c.cl_init with
| None -> ()
| Some e ->
c.cl_init <- Some (List.fold_left (fun e f -> f e) e filters));
| TEnumDecl _ -> ()
| TTypeDecl _ -> ()
| TAbstractDecl _ -> ()
let run_filters gen =
let last_error = gen.gcon.error in
let has_errors = ref false in
gen.gcon.error <- (fun msg pos -> has_errors := true; last_error msg pos);
(* first of all, we have to make sure that the filters won't trigger a major Gc collection *)
let t = Common.timer "gencommon_filters" in
(if Common.defined gen.gcon Define.GencommonDebug then debug_mode := true else debug_mode := false);
let run_filters filter =
let rec loop acc mds =
match mds with
| [] -> acc
| md :: tl ->
let filters = [ filter#run_f ] in
let added_types = ref [] in
gen.gadd_to_module <- (fun md_type priority ->
gen.gtypes_list <- md_type :: gen.gtypes_list;
added_types := (md_type, priority) :: !added_types
);
run_filters_from gen md filters;
let added_types = List.map (fun (t,p) ->
run_filters_from gen t [ fun e -> get (filter#run_from p e) ];
if Hashtbl.mem gen.gtypes (t_path t) then begin
let rec loop i =
let p = t_path t in
let new_p = (fst p, snd p ^ "_" ^ (string_of_int i)) in
if Hashtbl.mem gen.gtypes new_p then
loop (i+1)
else
match t with
| TClassDecl cl -> cl.cl_path <- new_p
| TEnumDecl e -> e.e_path <- new_p
| TTypeDecl _ | TAbstractDecl _ -> ()
in
loop 0
end;
Hashtbl.add gen.gtypes (t_path t) t;
t
) !added_types in
loop (added_types @ (md :: acc)) tl
in
List.rev (loop [] gen.gtypes_list)
in
let run_mod_filter filter =
let last_add_to_module = gen.gadd_to_module in
let added_types = ref [] in
gen.gadd_to_module <- (fun md_type priority ->
Hashtbl.add gen.gtypes (t_path md_type) md_type;
added_types := (md_type, priority) :: !added_types
);
let rec loop processed not_processed =
match not_processed with
| hd :: tl ->
(match hd with
| TClassDecl c ->
gen.gcurrent_class <- Some c
| _ ->
gen.gcurrent_class <- None);
let new_hd = filter#run_f hd in
let added_types_new = !added_types in
added_types := [];
let added_types = List.map (fun (t,p) ->
get (filter#run_from p t)
) added_types_new in
loop ( added_types @ (new_hd :: processed) ) tl
| [] ->
processed
in
let filtered = loop [] gen.gtypes_list in
gen.gadd_to_module <- last_add_to_module;
gen.gtypes_list <- List.rev (filtered)
in
run_mod_filter gen.gmodule_filters;
List.iter (fun fn -> fn()) gen.gafter_mod_filters_ended;
let last_add_to_module = gen.gadd_to_module in
gen.gtypes_list <- run_filters gen.gexpr_filters;
gen.gadd_to_module <- last_add_to_module;
List.iter (fun fn -> fn()) gen.gafter_expr_filters_ended;
(* Codegen.post_process gen.gtypes_list [gen.gexpr_filters#run_f]; *)
gen.gtypes_list <- run_filters gen.gsyntax_filters;
List.iter (fun fn -> fn()) gen.gafter_filters_ended;
reorder_modules gen;
t();
if !has_errors then raise (Abort("Compilation aborted with errors",null_pos))
(* ******************************************* *)
(* basic generation module that source code compilation implementations can use *)
(* ******************************************* *)
let write_file gen w source_dir path extension out_files =
let t = timer "write file" in
let s_path = source_dir ^ "/" ^ (snd path) ^ "." ^ (extension) in
(* create the folders if they don't exist *)
mkdir_from_path s_path;
let contents = SourceWriter.contents w in
let should_write = if not (Common.defined gen.gcon Define.ReplaceFiles) && Sys.file_exists s_path then begin
let in_file = open_in s_path in
let old_contents = Std.input_all in_file in
close_in in_file;
contents <> old_contents
end else true in
if should_write then begin
let f = open_out_bin s_path in
output_string f contents;
close_out f
end;
out_files := (unique_full_path s_path) :: !out_files;
t()
let clean_files path excludes verbose =
let rec iter_files pack dir path = try
let file = Unix.readdir dir in
if file <> "." && file <> ".." then begin
let filepath = path ^ "/" ^ file in
if (Unix.stat filepath).st_kind = S_DIR then
let pack = pack @ [file] in
iter_files (pack) (Unix.opendir filepath) filepath;
try Unix.rmdir filepath with Unix.Unix_error (ENOTEMPTY,_,_) -> ();
else if not (String.ends_with filepath ".meta") && not (List.mem (unique_full_path filepath) excludes) then begin
if verbose then print_endline ("Removing " ^ filepath);
Sys.remove filepath
end
end;
iter_files pack dir path
with | End_of_file | Unix.Unix_error _ ->
Unix.closedir dir
in
iter_files [] (Unix.opendir path) path
let dump_descriptor gen name path_s module_s =
let w = SourceWriter.new_source_writer () in
(* dump called path *)
SourceWriter.write w (Sys.getcwd());
SourceWriter.newline w;
(* dump all defines. deprecated *)
SourceWriter.write w "begin defines";
SourceWriter.newline w;
PMap.iter (fun name _ ->
SourceWriter.write w name;
SourceWriter.newline w
) gen.gcon.defines;
SourceWriter.write w "end defines";
SourceWriter.newline w;
(* dump all defines with their values; keeping the old defines for compatibility *)
SourceWriter.write w "begin defines_data";
SourceWriter.newline w;
PMap.iter (fun name v ->
SourceWriter.write w name;
SourceWriter.write w "=";
SourceWriter.write w v;
SourceWriter.newline w
) gen.gcon.defines;
SourceWriter.write w "end defines_data";
SourceWriter.newline w;
(* dump all generated types *)
SourceWriter.write w "begin modules";
SourceWriter.newline w;
let main_paths = Hashtbl.create 0 in
List.iter (fun md_def ->
SourceWriter.write w "M ";
SourceWriter.write w (path_s (path_of_md_def md_def));
SourceWriter.newline w;
List.iter (fun m ->
match m with
| TClassDecl cl when not cl.cl_extern ->
SourceWriter.write w "C ";
let s = module_s m in
Hashtbl.add main_paths cl.cl_path s;
SourceWriter.write w (s);
SourceWriter.newline w
| TEnumDecl e when not e.e_extern ->
SourceWriter.write w "E ";
SourceWriter.write w (module_s m);
SourceWriter.newline w
| _ -> () (* still no typedef or abstract is generated *)
) md_def.m_types
) gen.gmodules;
SourceWriter.write w "end modules";
SourceWriter.newline w;
(* dump all resources *)
(match gen.gcon.main_class with
| Some path ->
SourceWriter.write w "begin main";
SourceWriter.newline w;
(try
SourceWriter.write w (Hashtbl.find main_paths path)
with
| Not_found -> SourceWriter.write w (path_s path));
SourceWriter.newline w;
SourceWriter.write w "end main";
SourceWriter.newline w
| _ -> ()
);
SourceWriter.write w "begin resources";
SourceWriter.newline w;
Hashtbl.iter (fun name _ ->
SourceWriter.write w name;
SourceWriter.newline w
) gen.gcon.resources;
SourceWriter.write w "end resources";
SourceWriter.newline w;
SourceWriter.write w "begin libs";
SourceWriter.newline w;
let path file ext =
if Sys.file_exists file then
file
else try Common.find_file gen.gcon file with
| Not_found -> try Common.find_file gen.gcon (file ^ ext) with
| Not_found ->
file
in
if Common.platform gen.gcon Java then
List.iter (fun (s,std,_,_,_) ->
if not std then begin
SourceWriter.write w (path s ".jar");
SourceWriter.newline w;
end
) gen.gcon.java_libs
else if Common.platform gen.gcon Cs then
List.iter (fun (s,std,_,_) ->
if not std then begin
SourceWriter.write w (path s ".dll");
SourceWriter.newline w;
end
) gen.gcon.net_libs;
SourceWriter.write w "end libs";
SourceWriter.newline w;
let args = gen.gcon.c_args in
if args <> [] then begin
SourceWriter.write w "begin opts";
SourceWriter.newline w;
List.iter (fun opt -> SourceWriter.write w opt; SourceWriter.newline w) (List.rev args);
SourceWriter.write w "end opts";
SourceWriter.newline w;
end;
let contents = SourceWriter.contents w in
let f = open_out (gen.gcon.file ^ "/" ^ name) in
output_string f contents;
close_out f
let path_regex = Str.regexp "[/\\]+"
let normalize path =
let rec normalize acc m = match m with
| [] ->
List.rev acc
| Str.Text "." :: Str.Delim _ :: tl when acc = [] ->
normalize [] tl
| Str.Text ".." :: Str.Delim _ :: tl -> (match acc with
| [] -> raise Exit
| _ :: acc -> normalize acc tl)
| Str.Text t :: Str.Delim _ :: tl ->
normalize (t :: acc) tl
| Str.Delim _ :: tl ->
normalize ("" :: acc) tl
| Str.Text t :: [] ->
List.rev (t :: acc)
| Str.Text _ :: Str.Text _ :: _ -> assert false
in
String.concat "/" (normalize [] (Str.full_split path_regex path))
let is_relative cwd rel =
try
let rel = normalize rel in
Filename.is_relative rel || (String.starts_with rel cwd || String.starts_with (Common.unique_full_path rel) cwd)
with | Exit ->
String.starts_with rel cwd || String.starts_with (Common.unique_full_path rel) cwd
(*
helper function to create the source structure. Will send each module_def to the function passed.
If received true, it means that module_gen has generated this content, so the file must be saved.
See that it will write a whole module
*)
let generate_modules gen extension source_dir (module_gen : SourceWriter.source_writer->module_def->bool) out_files =
List.iter (fun md_def ->
let source_dir =
gen.gcon.file ^ "/" ^ source_dir ^ "/" ^ (String.concat "/" (fst (path_of_md_def md_def)))
in
let w = SourceWriter.new_source_writer () in
(*let should_write = List.fold_left (fun should md -> module_gen w md or should) false md_def.m_types in*)
let should_write = module_gen w md_def in
if should_write then begin
let path = path_of_md_def md_def in
write_file gen w source_dir path extension out_files
end
) gen.gmodules
let generate_modules_t gen extension source_dir change_path (module_gen : SourceWriter.source_writer->module_type->bool) out_files =
let source_dir = gen.gcon.file ^ "/" ^ source_dir in
List.iter (fun md ->
let w = SourceWriter.new_source_writer () in
(*let should_write = List.fold_left (fun should md -> module_gen w md or should) false md_def.m_types in*)
let should_write = module_gen w md in
if should_write then begin
let path = change_path (t_path md) in
write_file gen w (source_dir ^ "/" ^ (String.concat "/" (fst path))) path extension out_files;
end
) gen.gtypes_list
(*
various helper functions
*)
let mk_paren e =
match e.eexpr with | TParenthesis _ -> e | _ -> { e with eexpr=TParenthesis(e) }
(* private *)
let get_real_fun gen t =
match follow t with
| TFun(args,t) -> TFun(List.map (fun (n,o,t) -> n,o,gen.greal_type t) args, gen.greal_type t)
| _ -> t
let mk_int gen i pos = { eexpr = TConst(TInt ( Int32.of_int i)); etype = gen.gcon.basic.tint; epos = pos }
let mk_return e = { eexpr = TReturn (Some e); etype = e.etype; epos = e.epos }
let mk_temp gen name t =
incr tmp_count;
let name = gen.gmk_internal_name "temp" (name ^ (string_of_int !tmp_count)) in
alloc_var name t
let v_nativearray = alloc_var "__array__" t_dynamic
let mk_nativearray_decl gen t el pos =
{
eexpr = TCall(mk_local v_nativearray pos, el);
etype = gen.gclasses.nativearray t;
epos = pos;
}
let ensure_local gen block name e =
match e.eexpr with
| TLocal _ -> e
| _ ->
let var = mk_temp gen name e.etype in
block := { e with eexpr = TVar(var, Some e); etype = gen.gcon.basic.tvoid; } :: !block;
{ e with eexpr = TLocal var }
let follow_module follow_func md = match md with
| TClassDecl _
| TEnumDecl _
| TAbstractDecl _ -> md
| TTypeDecl tdecl -> match (follow_func (TType(tdecl, List.map snd tdecl.t_params))) with
| TInst(cl,_) -> TClassDecl cl
| TEnum(e,_) -> TEnumDecl e
| TType(t,_) -> TTypeDecl t
| TAbstract(a,_) -> TAbstractDecl a
| _ -> assert false
(*
hxgen means if the type was generated by haxe. If a type was generated by haxe, it means
it will contain special constructs for speedy reflection, for example
@see SetHXGen module
*)
let rec is_hxgen md =
match md with
| TClassDecl cl -> Meta.has Meta.HxGen cl.cl_meta
| TEnumDecl e -> Meta.has Meta.HxGen e.e_meta
| TTypeDecl t -> Meta.has Meta.HxGen t.t_meta || ( match follow t.t_type with | TInst(cl,_) -> is_hxgen (TClassDecl cl) | TEnum(e,_) -> is_hxgen (TEnumDecl e) | _ -> false )
| TAbstractDecl a -> Meta.has Meta.HxGen a.a_meta
let is_hxgen_t t =
match t with
| TInst (cl, _) -> Meta.has Meta.HxGen cl.cl_meta
| TEnum (e, _) -> Meta.has Meta.HxGen e.e_meta
| TAbstract (a, _) -> Meta.has Meta.HxGen a.a_meta
| TType (t, _) -> Meta.has Meta.HxGen t.t_meta
| _ -> false
let mt_to_t_dyn md =
match md with
| TClassDecl cl -> TInst(cl, List.map (fun _ -> t_dynamic) cl.cl_params)
| TEnumDecl e -> TEnum(e, List.map (fun _ -> t_dynamic) e.e_params)
| TAbstractDecl a -> TAbstract(a, List.map (fun _ -> t_dynamic) a.a_params)
| TTypeDecl t -> TType(t, List.map (fun _ -> t_dynamic) t.t_params)
let mt_to_t mt params =
match mt with
| TClassDecl (cl) -> TInst(cl, params)
| TEnumDecl (e) -> TEnum(e, params)
| TAbstractDecl a -> TAbstract(a, params)
| _ -> assert false
let t_to_mt t =
match follow t with
| TInst(cl, _) -> TClassDecl(cl)
| TEnum(e, _) -> TEnumDecl(e)
| TAbstract(a, _) -> TAbstractDecl a
| _ -> assert false
let rec get_last_ctor cl =
Option.map_default (fun (super,_) -> if is_some super.cl_constructor then Some(get super.cl_constructor) else get_last_ctor super) None cl.cl_super
let add_constructor cl cf =
match cl.cl_constructor with
| None -> cl.cl_constructor <- Some cf
| Some ctor ->
if ctor != cf && not (List.memq cf ctor.cf_overloads) then
ctor.cf_overloads <- cf :: ctor.cf_overloads
(* replace open TMonos with TDynamic *)
let rec replace_mono t =
match t with
| TMono t ->
(match !t with
| None -> t := Some t_dynamic
| Some _ -> ())
| TEnum (_,p) | TInst (_,p) | TType (_,p) | TAbstract (_,p) ->
List.iter replace_mono p
| TFun (args,ret) ->
List.iter (fun (_,_,t) -> replace_mono t) args;
replace_mono ret
| TAnon _
| TDynamic _ -> ()
| TLazy f ->
replace_mono (!f())
(* helper *)
let mk_class_field name t public pos kind params =
{
cf_name = name;
cf_type = t;
cf_public = public;
cf_pos = pos;
cf_doc = None;
cf_meta = [ Meta.CompilerGenerated, [], Ast.null_pos ]; (* annotate that this class field was generated by the compiler *)
cf_kind = kind;
cf_params = params;
cf_expr = None;
cf_overloads = [];
}
(* this helper just duplicates the type parameter class, which is assumed that cl is. *)
(* This is so we can use class parameters on function parameters, without running the risk of name clash *)
(* between both *)
let map_param cl =
let ret = mk_class cl.cl_module (fst cl.cl_path, snd cl.cl_path ^ "_c") cl.cl_pos in
ret.cl_implements <- cl.cl_implements;
ret.cl_kind <- cl.cl_kind;
ret
let get_cl_t t =
match follow t with | TInst (cl,_) -> cl | _ -> assert false
let mk_class m path pos =
let cl = Type.mk_class m path pos in
cl.cl_meta <- [ Meta.CompilerGenerated, [], Ast.null_pos ];
cl
type tfield_access =
| FClassField of tclass * tparams * tclass (* declared class *) * tclass_field * bool (* is static? *) * t (* the actual cf type, in relation to the class type params *) * t (* declared type *)
| FEnumField of tenum * tenum_field * bool (* is parameterized enum ? *)
| FAnonField of tclass_field
| FDynamicField of t
| FNotFound
let is_var f = match f.cf_kind with | Var _ -> true | _ -> false
let find_first_declared_field gen orig_cl ?get_vmtype ?exact_field field =
let get_vmtype = match get_vmtype with None -> (fun t -> t) | Some f -> f in
let chosen = ref None in
let is_overload = ref false in
let rec loop_cl depth c tl tlch =
(try
let ret = PMap.find field c.cl_fields in
if Meta.has Meta.Overload ret.cf_meta then is_overload := true;
match !chosen, exact_field with
| Some(d,f,_,_,_), _ when depth <= d || (is_var ret && not (is_var f)) -> ()
| _, None ->
chosen := Some(depth,ret,c,tl,tlch)
| _, Some f2 ->
List.iter (fun f ->
let declared_t = apply_params c.cl_params tl f.cf_type in
if Typeload.same_overload_args ~get_vmtype declared_t f2.cf_type f f2 then
chosen := Some(depth,f,c,tl,tlch)
) (ret :: ret.cf_overloads)
with | Not_found -> ());
(match c.cl_super with
| Some (sup,stl) ->
let tl = List.map (apply_params c.cl_params tl) stl in
let stl = gen.greal_type_param (TClassDecl sup) stl in
let tlch = List.map (apply_params c.cl_params tlch) stl in
loop_cl (depth+1) sup tl tlch
| None -> ());
if c.cl_interface then
List.iter (fun (sup,stl) ->
let tl = List.map (apply_params c.cl_params tl) stl in
let stl = gen.greal_type_param (TClassDecl sup) stl in
let tlch = List.map (apply_params c.cl_params tlch) stl in
loop_cl (depth+1) sup tl tlch
) c.cl_implements
in
loop_cl 0 orig_cl (List.map snd orig_cl.cl_params) (List.map snd orig_cl.cl_params);
match !chosen with
| None -> None
| Some(_,f,c,tl,tlch) ->
if !is_overload && not (Meta.has Meta.Overload f.cf_meta) then
f.cf_meta <- (Meta.Overload,[],f.cf_pos) :: f.cf_meta;
let declared_t = apply_params c.cl_params tl f.cf_type in
let params_t = apply_params c.cl_params tlch f.cf_type in
let actual_t = match follow params_t with
| TFun(args,ret) -> TFun(List.map (fun (n,o,t) -> (n,o,gen.greal_type t)) args, gen.greal_type ret)
| _ -> gen.greal_type params_t in
Some(f,actual_t,declared_t,params_t,c,tl,tlch)
let field_access gen (t:t) (field:string) : (tfield_access) =
(*
t can be either an haxe-type as a real-type;
'follow' should be applied here since we can generalize that a TType will be accessible as its
underlying type.
*)
(* let pointers to values be accessed as the underlying values *)
let t = match gen.greal_type t with
| TAbstract({ a_path = ["cs"],"Pointer" },[t]) ->
gen.greal_type t
| _ -> t
in
match follow t with
| TInst(cl, params) ->
let orig_cl = cl in
let orig_params = params in
let rec not_found cl params =
match cl.cl_dynamic with
| Some t ->
let t = apply_params cl.cl_params params t in
FDynamicField t
| None ->
match cl.cl_super with
| None -> FNotFound
| Some (super,p) -> not_found super p
in
let not_found () =
try
let cf = PMap.find field gen.gbase_class_fields in
FClassField (orig_cl, orig_params, gen.gclasses.cl_dyn, cf, false, cf.cf_type, cf.cf_type)
with
| Not_found -> not_found cl params
in
(* this is a hack for C#'s different generic types with same path *)
let hashtbl_field = (String.concat "" (List.map (fun _ -> "]") cl.cl_params)) ^ field in
let types = try
Hashtbl.find gen.greal_field_types (orig_cl.cl_path, hashtbl_field)
with | Not_found ->
let ret = find_first_declared_field gen cl field in
let ret = match ret with
| None -> None
| Some(cf,t,dt,_,cl,_,_) -> Some(cf,t,dt,cl)
in
if ret <> None then Hashtbl.add gen.greal_field_types (orig_cl.cl_path, hashtbl_field) ret;
ret
in
(match types with
| None -> not_found()
| Some (cf, actual_t, declared_t, declared_cl) ->
FClassField(orig_cl, orig_params, declared_cl, cf, false, actual_t, declared_t))
| TEnum _ | TAbstract _ ->
(* enums have no field *) FNotFound
| TAnon anon ->
(try match !(anon.a_status) with
| Statics cl ->
let cf = PMap.find field cl.cl_statics in
FClassField(cl, List.map (fun _ -> t_dynamic) cl.cl_params, cl, cf, true, cf.cf_type, cf.cf_type)
| EnumStatics e ->
let f = PMap.find field e.e_constrs in
let is_param = match follow f.ef_type with | TFun _ -> true | _ -> false in
FEnumField(e, f, is_param)
| _ when PMap.mem field gen.gbase_class_fields ->
let cf = PMap.find field gen.gbase_class_fields in
FClassField(gen.gclasses.cl_dyn, [t_dynamic], gen.gclasses.cl_dyn, cf, false, cf.cf_type, cf.cf_type)
| _ ->
FAnonField(PMap.find field anon.a_fields)
with | Not_found -> FNotFound)
| _ when PMap.mem field gen.gbase_class_fields ->
let cf = PMap.find field gen.gbase_class_fields in
FClassField(gen.gclasses.cl_dyn, [t_dynamic], gen.gclasses.cl_dyn, cf, false, cf.cf_type, cf.cf_type)
| TDynamic t -> FDynamicField t
| TMono _ -> FDynamicField t_dynamic
| _ -> FNotFound
let field_access_esp gen t field = match field with
| FStatic(cl,cf) | FInstance(cl,_,cf) when Meta.has Meta.Extern cf.cf_meta ->
let static = match field with
| FStatic _ -> true
| _ -> false
in
let p = match follow (run_follow gen t) with
| TInst(_,p) -> p
| _ -> List.map snd cl.cl_params
in
FClassField(cl,p,cl,cf,static,cf.cf_type,cf.cf_type)
| _ -> field_access gen t (field_name field)
let mk_field_access gen expr field pos =
match field_access gen expr.etype field with
| FClassField(c,p,dc,cf,false,at,_) ->
{ eexpr = TField(expr, FInstance(dc,p,cf)); etype = apply_params c.cl_params p at; epos = pos }
| FClassField(c,p,dc,cf,true,at,_) ->
{ eexpr = TField(expr, FStatic(dc,cf)); etype = at; epos = pos }
| FAnonField cf ->
{ eexpr = TField(expr, FAnon cf); etype = cf.cf_type; epos = pos }
| FDynamicField t ->
{ eexpr = TField(expr, FDynamic field); etype = t; epos = pos }
| FNotFound ->
{ eexpr = TField(expr, FDynamic field); etype = t_dynamic; epos = pos }
| FEnumField _ -> assert false
let mk_iterator_access gen t expr =
let pos = expr.epos in
let itf = mk_field_access gen expr "iterator" pos in
{ eexpr = TCall(itf, []); epos = pos; etype = snd (get_fun itf.etype) }
(* ******************************************* *)
(* Module dependency resolution *)
(* ******************************************* *)
type t_dependency =
| DAfter of float
| DBefore of float
exception ImpossibleDependency of string
let max_dep = 10000.0
let min_dep = - (10000.0)
let solve_deps name (deps:t_dependency list) =
let vmin = min_dep -. 1.0 in
let vmax = max_dep +. 1.0 in
let rec loop dep vmin vmax =
match dep with
| [] ->
(if vmin >= vmax then raise (ImpossibleDependency name));
(vmin +. vmax) /. 2.0
| head :: tail ->
match head with
| DBefore f ->
loop tail (max vmin f) vmax
| DAfter f ->
loop tail vmin (min vmax f)
in
loop deps vmin vmax
(* type resolution *)
exception TypeNotFound of path
let get_type gen path =
try Hashtbl.find gen.gtypes path with | Not_found -> raise (TypeNotFound path)
(* ******************************************* *)
(* follow all module *)
(* ******************************************* *)
(*
this module will follow each and every type using the rules defined in
gen.gfollow. This is a minor helper module, so we don't end up
having to follow the same time multiple times in the many filter iterations
because of this, it will be one of the first modules to run.
*)
module FollowAll =
struct
let follow gen e =
let follow_func = gen.gfollow#run_f in
Some (Type.map_expr_type (fun e->e) (follow_func) (fun tvar-> tvar.v_type <- (follow_func tvar.v_type); tvar) e)
let priority = max_dep
(* will add an expression filter as the first filter *)
let configure gen =
gen.gexpr_filters#add ~name:"follow_all" ~priority:(PCustom(priority)) (follow gen)
end;;
(* ******************************************* *)
(* set hxgen module *)
(* ******************************************* *)
(*
goes through all module types and sets the :hxgen meta on all which
then is_hxgen_func returns true. There is a default is_hxgen_func implementation also
*)
module SetHXGen =
struct
(*
basically, everything that is extern is assumed to not be hxgen, unless meta :hxgen is set, and
everything that is not extern is assumed to be hxgen, unless meta :nativegen is set
*)
let rec default_hxgen_func md =
match md with
| TClassDecl { cl_kind = KAbstractImpl a } ->
default_hxgen_func (TAbstractDecl a)
| TClassDecl cl ->
let rec is_hxgen_class (c,_) =
if c.cl_extern then begin
if Meta.has Meta.HxGen c.cl_meta then true else Option.map_default (is_hxgen_class) false c.cl_super || List.exists is_hxgen_class c.cl_implements
end else begin
if Meta.has Meta.NativeChildren c.cl_meta || Meta.has Meta.NativeGen c.cl_meta then
Option.map_default (is_hxgen_class) false c.cl_super || List.exists is_hxgen_class c.cl_implements
else
let rec has_nativec (c,p) =
if is_hxgen_class (c,p) then
false
else
(Meta.has Meta.NativeChildren c.cl_meta && not (Option.map_default is_hxgen_class false c.cl_super || List.exists is_hxgen_class c.cl_implements))
|| Option.map_default has_nativec false c.cl_super
in
if Option.map_default has_nativec false c.cl_super && not (List.exists is_hxgen_class c.cl_implements) then
false
else
true
end
in
is_hxgen_class (cl,[])
| TEnumDecl e -> if e.e_extern then Meta.has Meta.HxGen e.e_meta else not (Meta.has Meta.NativeGen e.e_meta)
| TAbstractDecl a when Meta.has Meta.CoreType a.a_meta -> not (Meta.has Meta.NativeGen a.a_meta)
| TAbstractDecl a -> (match follow a.a_this with
| TInst _ | TEnum _ | TAbstract _ ->
default_hxgen_func (t_to_md (follow a.a_this))
| _ ->
not (Meta.has Meta.NativeGen a.a_meta))
| TTypeDecl t -> (* TODO see when would we use this *)
false
(*
by now the only option is to run it eagerly, because it must be one of the first filters to run,
since many others depend of it
*)
let run_filter gen is_hxgen_func =
let filter md =
let meta = if is_hxgen_func md then Meta.HxGen else Meta.NativeGen in
begin
match md with
| TClassDecl cl -> cl.cl_meta <- (meta, [], cl.cl_pos) :: cl.cl_meta
| TEnumDecl e -> e.e_meta <- (meta, [], e.e_pos) :: e.e_meta
| TTypeDecl t -> t.t_meta <- (meta, [], t.t_pos) :: t.t_meta
| TAbstractDecl a -> a.a_meta <- (meta, [], a.a_pos) :: a.a_meta
end
in
List.iter filter gen.gtypes_list
end;;
(* ******************************************* *)
(* overloading reflection constructors *)
(* ******************************************* *)
(*
this module works on languages that support function overloading and
enable function hiding via static functions.
it takes the constructor body out of the constructor and adds it to a special ctor
static function. The static function will receive the same parameters as the constructor,
plus the special "me" var, which will replace "this"
Then it always adds two constructors to the function: one that receives a special class,
indicating that it should be constructed without any parameters, and one that receives its normal constructor.
Both will only include a super() call to the superclasses' emtpy constructor.
This enables two things:
empty construction without the need of incompatibility with the platform's native construction method
the ability to call super() constructor in any place in the constructor
This will insert itself in the default reflection-related module filter
*)
module OverloadingConstructor =
struct
let priority = 0.0
let name = "overloading_constructor"
let set_new_create_empty gen empty_ctor_expr =
let old = gen.gtools.rf_create_empty in
gen.gtools.rf_create_empty <- (fun cl params pos ->
if is_hxgen (TClassDecl cl) then
{ eexpr = TNew(cl,params,[empty_ctor_expr]); etype = TInst(cl,params); epos = pos }
else
old cl params pos
)
let rec cur_ctor c tl =
match c.cl_constructor with
| Some ctor -> ctor, c, tl
| None -> match c.cl_super with
| None -> raise Not_found
| Some (sup,stl) ->
cur_ctor sup (List.map (apply_params c.cl_params tl) stl)
let rec prev_ctor c tl =
match c.cl_super with
| None -> raise Not_found
| Some (sup,stl) ->
let stl = List.map (apply_params c.cl_params tl) stl in
match sup.cl_constructor with
| None -> prev_ctor sup stl
| Some ctor -> ctor, sup, stl
(* replaces super() call with last static constructor call *)
let replace_super_call gen name c tl with_params me p =
let rec loop_super c tl = match c.cl_super with
| None -> raise Not_found
| Some(sup,stl) ->
let stl = List.map (apply_params c.cl_params tl) stl in
try
let static_ctor_name = name ^ "_" ^ (String.concat "_" (fst sup.cl_path)) ^ "_" ^ (snd sup.cl_path) in
sup, stl, PMap.find static_ctor_name sup.cl_statics
with | Not_found ->
loop_super sup stl
in
let sup, stl, cf = loop_super c tl in
let with_params = { eexpr = TLocal me; etype = me.v_type; epos = p } :: with_params in
let cf = match cf.cf_overloads with
(* | [] -> cf *)
| _ -> try
(* choose best super function *)
List.iter (fun e -> replace_mono e.etype) with_params;
List.find (fun cf ->
replace_mono cf.cf_type;
let args, _ = get_fun (apply_params cf.cf_params stl cf.cf_type) in
try
List.for_all2 (fun (_,_,t) e -> try
let e_etype = run_follow gen e.etype in
let t = run_follow gen t in
unify e_etype t; true
with | Unify_error _ -> false) args with_params
with | Invalid_argument("List.for_all2") -> false
) (cf :: cf.cf_overloads)
with | Not_found ->
gen.gcon.error "No suitable overload for the super call arguments was found" p; cf
in
{
eexpr = TCall({
eexpr = TField(
mk_classtype_access sup p,
FStatic(sup,cf));
etype = apply_params cf.cf_params stl cf.cf_type;
epos = p},
with_params);
etype = gen.gcon.basic.tvoid;
epos = p;
}
(* will create a static counterpart of 'ctor', and replace its contents to a call to the static version*)
let create_static_ctor gen ~empty_ctor_expr cl name ctor =
match Meta.has Meta.SkipCtor ctor.cf_meta with
| true -> ()
| false when is_none ctor.cf_expr -> ()
| false ->
let static_ctor_name = name ^ "_" ^ (String.concat "_" (fst cl.cl_path)) ^ "_" ^ (snd cl.cl_path) in
(* create the static constructor *)
let basic = gen.gcon.basic in
let ctor_types = List.map (fun (s,t) -> (s, TInst(map_param (get_cl_t t), []))) cl.cl_params in
let me = mk_temp gen "me" (TInst(cl, List.map snd ctor_types)) in
me.v_capture <- true;
let fn_args, _ = get_fun ctor.cf_type in
let ctor_params = List.map snd ctor_types in
let fn_type = TFun((me.v_name,false, me.v_type) :: List.map (fun (n,o,t) -> (n,o,apply_params cl.cl_params ctor_params t)) fn_args, basic.tvoid) in
let cur_tf_args = match ctor.cf_expr with
| Some { eexpr = TFunction(tf) } -> tf.tf_args
| _ -> assert false
in
let changed_tf_args = List.map (fun (v,_) -> (v,None)) cur_tf_args in
let local_map = Hashtbl.create (List.length cur_tf_args) in
let static_tf_args = (me, None) :: List.map (fun (v,b) ->
let new_v = alloc_var v.v_name (apply_params cl.cl_params ctor_params v.v_type) in
new_v.v_capture <- v.v_capture;
Hashtbl.add local_map v.v_id new_v;
(new_v, b)
) cur_tf_args in
let static_ctor = mk_class_field static_ctor_name fn_type false ctor.cf_pos (Method MethNormal) ctor_types in
(* change ctor contents to reference the 'me' var instead of 'this' *)
let actual_super_call = ref None in
let rec map_expr ~is_first e = match e.eexpr with
| TCall (({ eexpr = TConst TSuper } as tsuper), params) -> (try
let params = List.map (fun e -> map_expr ~is_first:false e) params in
actual_super_call := Some { e with eexpr = TCall(tsuper, [empty_ctor_expr]) };
replace_super_call gen name cl ctor_params params me e.epos
with | Not_found ->
(* last static function was not found *)
actual_super_call := Some e;
if not is_first then
gen.gcon.error "Super call must be the first call when extending native types" e.epos;
{ e with eexpr = TBlock([]) })
| TFunction tf when is_first ->
do_map ~is_first:true e
| TConst TThis ->
mk_local me e.epos
| TBlock (fst :: bl) ->
let fst = map_expr ~is_first:is_first fst in
{ e with eexpr = TBlock(fst :: List.map (fun e -> map_expr ~is_first:false e) bl); etype = apply_params cl.cl_params ctor_params e.etype }
| _ ->
do_map e
and do_map ?(is_first=false) e =
let do_t = apply_params cl.cl_params ctor_params in
let do_v v = try
Hashtbl.find local_map v.v_id
with | Not_found ->
v.v_type <- do_t v.v_type; v
in
Type.map_expr_type (map_expr ~is_first:is_first) do_t do_v e
in
let expr = do_map ~is_first:true (get ctor.cf_expr) in
let expr = match expr.eexpr with
| TFunction(tf) ->
{ expr with etype = fn_type; eexpr = TFunction({ tf with tf_args = static_tf_args }) }
| _ -> assert false in
static_ctor.cf_expr <- Some expr;
(* add to the statics *)
(try
let stat = PMap.find static_ctor_name cl.cl_statics in
stat.cf_overloads <- static_ctor :: stat.cf_overloads
with | Not_found ->
cl.cl_ordered_statics <- static_ctor :: cl.cl_ordered_statics;
cl.cl_statics <- PMap.add static_ctor_name static_ctor cl.cl_statics);
(* change current super call *)
match ctor.cf_expr with
| Some({ eexpr = TFunction(tf) } as e) ->
let block_contents, p = match !actual_super_call with
| None -> [], ctor.cf_pos
| Some super -> [super], super.epos
in
let block_contents = block_contents @ [{
eexpr = TCall(
{
eexpr = TField(
mk_classtype_access cl p,
FStatic(cl, static_ctor));
etype = apply_params static_ctor.cf_params (List.map snd cl.cl_params) static_ctor.cf_type;
epos = p
},
[{ eexpr = TConst TThis; etype = TInst(cl, List.map snd cl.cl_params); epos = p }]
@ List.map (fun (v,_) -> mk_local v p) cur_tf_args
);
etype = basic.tvoid;
epos = p
}] in
ctor.cf_expr <- Some { e with eexpr = TFunction({ tf with tf_expr = { tf.tf_expr with eexpr = TBlock block_contents }; tf_args = changed_tf_args }) }
| _ -> assert false
(* makes constructors that only call super() for the 'ctor' argument *)
let clone_ctors gen ctor sup stl cl =
let basic = gen.gcon.basic in
let rec clone cf =
let ncf = mk_class_field "new" (apply_params sup.cl_params stl cf.cf_type) cf.cf_public cf.cf_pos cf.cf_kind cf.cf_params in
let args, ret = get_fun ncf.cf_type in
(* single expression: call to super() *)
let tf_args = List.map (fun (name,_,t) ->
(* the constructor will have no optional arguments, as presumably this will be handled by the underlying expr *)
alloc_var name t, None
) args in
let super_call =
{
eexpr = TCall(
{ eexpr = TConst TSuper; etype = TInst(cl, List.map snd cl.cl_params); epos = ctor.cf_pos },
List.map (fun (v,_) -> mk_local v ctor.cf_pos) tf_args);
etype = basic.tvoid;
epos = ctor.cf_pos;
} in
ncf.cf_expr <- Some
{
eexpr = TFunction {
tf_args = tf_args;
tf_type = basic.tvoid;
tf_expr = mk_block super_call;
};
etype = ncf.cf_type;
epos = ctor.cf_pos;
};
ncf
in
(* take off createEmpty *)
let all = List.filter (fun cf -> replace_mono cf.cf_type; not (Meta.has Meta.SkipCtor cf.cf_meta)) (ctor :: ctor.cf_overloads) in
let clones = List.map clone all in
match clones with
| [] ->
(* raise Not_found *)
assert false (* should never happen *)
| cf :: [] -> cf
| cf :: overl ->
cf.cf_meta <- (Meta.Overload,[],cf.cf_pos) :: cf.cf_meta;
cf.cf_overloads <- overl; cf
let rec descends_from_native_or_skipctor cl =
not (is_hxgen (TClassDecl cl)) || Meta.has Meta.SkipCtor cl.cl_meta || match cl.cl_super with
| None -> false
| Some(c,_) -> descends_from_native_or_skipctor c
let ensure_super_is_first gen cf =
let rec loop e =
match e.eexpr with
| TBlock (b :: block) ->
loop b
| TBlock []
| TCall({ eexpr = TConst TSuper },_) -> ()
| _ ->
gen.gcon.error "Types that derive from a native class must have its super() call as the first statement in the constructor" cf.cf_pos
in
match cf.cf_expr with
| None -> ()
| Some e -> Type.iter loop e
(* major restructring made at r6493 *)
let configure ~(empty_ctor_type : t) ~(empty_ctor_expr : texpr) ~supports_ctor_inheritance gen =
set_new_create_empty gen empty_ctor_expr;
let basic = gen.gcon.basic in
let should_change cl = not cl.cl_interface && (not cl.cl_extern || is_hxgen (TClassDecl cl)) && (match cl.cl_kind with KAbstractImpl _ -> false | _ -> true) in
let static_ctor_name = gen.gmk_internal_name "hx" "ctor" in
let msize = List.length gen.gtypes_list in
let processed, empty_ctors = Hashtbl.create msize, Hashtbl.create msize in
let rec get_last_empty cl =
try
Hashtbl.find empty_ctors cl.cl_path
with | Not_found ->
match cl.cl_super with
| None -> raise Not_found
| Some (sup,_) -> get_last_empty sup
in
let rec change cl =
match Hashtbl.mem processed cl.cl_path with
| true -> ()
| false ->
Hashtbl.add processed cl.cl_path true;
(* make sure we've processed the super types *)
(match cl.cl_super with
| Some (super,_) when should_change super && not (Hashtbl.mem processed super.cl_path) ->
change super
| _ -> ());
(* implement static hx_ctor and reimplement constructors *)
(try
let ctor = match cl.cl_constructor with
| Some ctor -> ctor
| None -> try
let sctor, sup, stl = prev_ctor cl (List.map snd cl.cl_params) in
(* we have a previous constructor. if we support inheritance, exit *)
if supports_ctor_inheritance then raise Exit;
(* we'll make constructors that will only call super() *)
let ctor = clone_ctors gen sctor sup stl cl in
cl.cl_constructor <- Some ctor;
ctor
with | Not_found -> (* create default constructor *)
let ctor = mk_class_field "new" (TFun([], basic.tvoid)) false cl.cl_pos (Method MethNormal) [] in
ctor.cf_expr <- Some
{
eexpr = TFunction {
tf_args = [];
tf_type = basic.tvoid;
tf_expr = { eexpr = TBlock[]; etype = basic.tvoid; epos = cl.cl_pos };
};
etype = ctor.cf_type;
epos = ctor.cf_pos;
};
cl.cl_constructor <- Some ctor;
ctor
in
(* now that we made sure we have a constructor, exit if native gen *)
if not (is_hxgen (TClassDecl cl)) || Meta.has Meta.SkipCtor cl.cl_meta then begin
if descends_from_native_or_skipctor cl && is_some cl.cl_super then
List.iter (fun cf -> ensure_super_is_first gen cf) (ctor :: ctor.cf_overloads);
raise Exit
end;
(* if cl descends from a native class, we cannot use the static constructor strategy *)
if descends_from_native_or_skipctor cl && is_some cl.cl_super then
List.iter (fun cf -> ensure_super_is_first gen cf) (ctor :: ctor.cf_overloads)
else
(* now that we have a current ctor, create the static counterparts *)
List.iter (fun cf ->
create_static_ctor gen ~empty_ctor_expr:empty_ctor_expr cl static_ctor_name cf
) (ctor :: ctor.cf_overloads)
with | Exit ->());
(* implement empty ctor *)
(try
(* now that we made sure we have a constructor, exit if native gen *)
if not (is_hxgen (TClassDecl cl)) then raise Exit;
(* get first *)
let empty_type = TFun(["empty",false,empty_ctor_type],basic.tvoid) in
let super = match cl.cl_super with
| None -> (* implement empty *)
[]
| Some (sup,_) -> try
ignore (get_last_empty sup);
if supports_ctor_inheritance && is_none cl.cl_constructor then raise Exit;
[{
eexpr = TCall(
{ eexpr = TConst TSuper; etype = TInst(cl, List.map snd cl.cl_params); epos = cl.cl_pos },
[ empty_ctor_expr ]);
etype = basic.tvoid;
epos = cl.cl_pos
}]
with | Not_found -> try
(* super type is native: find super constructor with least arguments *)
let sctor, sup, stl = prev_ctor cl (List.map snd cl.cl_params) in
let rec loop remaining (best,n) =
match remaining with
| [] -> best
| cf :: r ->
let args,_ = get_fun cf.cf_type in
if (List.length args) < n then
loop r (cf,List.length args)
else
loop r (best,n)
in
let args,_ = get_fun sctor.cf_type in
let best = loop sctor.cf_overloads (sctor, List.length args) in
let args,_ = get_fun (apply_params sup.cl_params stl best.cf_type) in
[{
eexpr = TCall(
{ eexpr = TConst TSuper; etype = TInst(sup, stl); epos = cl.cl_pos },
List.map (fun (n,o,t) -> null t cl.cl_pos) args);
etype = basic.tvoid;
epos = cl.cl_pos
}]
with | Not_found ->
(* extends native type, but no ctor found *)
[]
in
let ctor = mk_class_field "new" empty_type false cl.cl_pos (Method MethNormal) [] in
ctor.cf_expr <- Some {
eexpr = TFunction {
tf_type = basic.tvoid;
tf_args = [alloc_var "empty" empty_ctor_type, None];
tf_expr = { eexpr = TBlock super; etype = basic.tvoid; epos = cl.cl_pos }
};
etype = empty_type;
epos = cl.cl_pos;
};
ctor.cf_meta <- [Meta.SkipCtor, [], ctor.cf_pos];
Hashtbl.add empty_ctors cl.cl_path ctor;
match cl.cl_constructor with
| None -> cl.cl_constructor <- Some ctor
| Some c -> c.cf_overloads <- ctor :: c.cf_overloads
with | Exit -> ());
in
let module_filter md = match md with
| TClassDecl cl when should_change cl && not (Hashtbl.mem processed cl.cl_path) ->
change cl;
None
| _ -> None
in
gen.gmodule_filters#add ~name:name ~priority:(PCustom priority) module_filter
end;;
(* ******************************************* *)
(* init function module *)
(* ******************************************* *)
(*
This module will take proper care of the init function, by taking off all expressions from static vars and putting them
in order in the init function.
It will also initialize dynamic functions, both by putting them in the constructor and in the init function
depends on:
(syntax) must run before ExprStatement module
(ok) must run before OverloadingCtor module so the constructor can be in the correct place
(syntax) must run before FunctionToClass module
*)
module InitFunction =
struct
let name = "init_funcs"
let priority = solve_deps name [DBefore OverloadingConstructor.priority]
let ensure_simple_expr gen e =
let rec iter e = match e.eexpr with
| TConst _ | TLocal _ | TArray _ | TBinop _
| TField _ | TTypeExpr _ | TParenthesis _ | TCast _
| TCall _ | TNew _ | TUnop _ ->
Type.iter iter e
| _ ->
print_endline (debug_expr e);
gen.gcon.error "Expression is too complex for a readonly variable initialization" e.epos
in
iter e
let configure gen should_handle_dynamic_functions readonly_support =
let handle_override_dynfun acc e this field =
let add_expr = ref None in
let v = mk_temp gen ("super_" ^ field) e.etype in
v.v_capture <- true;
let rec loop e =
match e.eexpr with
| TField({ eexpr = TConst(TSuper) }, f) ->
let n = field_name f in
(if n <> field then assert false);
let local = mk_local v e.epos in
(match !add_expr with
| None ->
add_expr := Some { e with eexpr = TVar(v, Some this) }
| Some _ -> ());
local
| TConst TSuper -> assert false
| _ -> Type.map_expr loop e
in
let e = loop e in
match !add_expr with
| None -> e :: acc
| Some add_expr -> add_expr :: e :: acc
in
let handle_class cl =
let init = match cl.cl_init with
| None -> []
| Some i -> [i]
in
let init = List.fold_left (fun acc cf ->
match cf.cf_kind, should_handle_dynamic_functions with
| (Var v, _) when Meta.has Meta.ReadOnly cf.cf_meta && readonly_support ->
if v.v_write <> AccNever && not (Meta.has Meta.CoreApi cl.cl_meta) then gen.gcon.warning "@:readOnly variable declared without `never` setter modifier" cf.cf_pos;
(match cf.cf_expr with
| None -> gen.gcon.warning "Uninitialized readonly variable" cf.cf_pos; acc
| Some e -> ensure_simple_expr gen e; acc)
| (Var _, _)
| (Method (MethDynamic), true) when not (Type.is_extern_field cf) ->
(match cf.cf_expr with
| Some e ->
(match cf.cf_params with
| [] ->
let var = { eexpr = TField(mk_classtype_access cl cf.cf_pos, FStatic(cl,cf)); etype = cf.cf_type; epos = cf.cf_pos } in
let ret = ({ eexpr = TBinop(Ast.OpAssign, var, e); etype = cf.cf_type; epos = cf.cf_pos; }) in
cf.cf_expr <- None;
ret :: acc
| _ ->
let params = List.map (fun _ -> t_dynamic) cf.cf_params in
let fn = apply_params cf.cf_params params in
let var = { eexpr = TField(mk_classtype_access cl cf.cf_pos, FStatic(cl,cf)); etype = fn cf.cf_type; epos = cf.cf_pos } in
let rec change_expr e =
Type.map_expr_type (change_expr) fn (fun v -> v.v_type <- fn v.v_type; v) e
in
let ret = ({ eexpr = TBinop(Ast.OpAssign, var, change_expr e); etype = fn cf.cf_type; epos = cf.cf_pos; }) in
cf.cf_expr <- None;
ret :: acc
)
| None -> acc)
| _ -> acc
) init cl.cl_ordered_statics
in
let init = List.rev init in
(match init with
| [] -> cl.cl_init <- None
| _ -> cl.cl_init <- Some { eexpr = TBlock(init); epos = cl.cl_pos; etype = gen.gcon.basic.tvoid; });
(* FIXME: find a way to tell OverloadingCtors to execute this code even with empty constructors *)
if should_handle_dynamic_functions then begin
let vars, funs = List.fold_left (fun (acc_vars,acc_funs) cf ->
match cf.cf_kind with
| Var v when Meta.has Meta.ReadOnly cf.cf_meta && readonly_support ->
if v.v_write <> AccNever && not (Meta.has Meta.CoreApi cl.cl_meta) then gen.gcon.warning "@:readOnly variable declared without `never` setter modifier" cf.cf_pos;
(match cf.cf_expr with
| None -> (acc_vars,acc_funs)
| Some e -> ensure_simple_expr gen e; (acc_vars,acc_funs))
| Var _
| Method(MethDynamic) ->
let is_var = match cf.cf_kind with | Var _ -> true | _ -> false in
(match cf.cf_expr, cf.cf_params with
| Some e, [] ->
let var = { eexpr = TField({ eexpr = TConst(TThis); epos = cf.cf_pos; etype = TInst(cl, List.map snd cl.cl_params); }, FInstance(cl, List.map snd cl.cl_params, cf)); etype = cf.cf_type; epos = cf.cf_pos } in
let ret = ({ eexpr = TBinop(Ast.OpAssign, var, e); etype = cf.cf_type; epos = cf.cf_pos; }) in
cf.cf_expr <- None;
let is_override = List.memq cf cl.cl_overrides in
if is_override then begin
cl.cl_ordered_fields <- List.filter (fun f -> f.cf_name <> cf.cf_name) cl.cl_ordered_fields;
cl.cl_fields <- PMap.remove cf.cf_name cl.cl_fields;
acc_vars, handle_override_dynfun acc_funs ret var cf.cf_name
end else if is_var then
ret :: acc_vars, acc_funs
else
acc_vars, ret :: acc_funs
| Some e, _ ->
let params = List.map (fun _ -> t_dynamic) cf.cf_params in
let fn = apply_params cf.cf_params params in
let var = { eexpr = TField({ eexpr = TConst(TThis); epos = cf.cf_pos; etype = TInst(cl, List.map snd cl.cl_params); }, FInstance(cl, List.map snd cl.cl_params, cf)); etype = cf.cf_type; epos = cf.cf_pos } in
let rec change_expr e =
Type.map_expr_type (change_expr) fn (fun v -> v.v_type <- fn v.v_type; v) e
in
let ret = ({ eexpr = TBinop(Ast.OpAssign, var, change_expr e); etype = fn cf.cf_type; epos = cf.cf_pos; }) in
cf.cf_expr <- None;
let is_override = List.memq cf cl.cl_overrides in
if is_override then begin
cl.cl_ordered_fields <- List.filter (fun f -> f.cf_name <> cf.cf_name) cl.cl_ordered_fields;
cl.cl_fields <- PMap.remove cf.cf_name cl.cl_fields;
acc_vars, handle_override_dynfun acc_funs ret var cf.cf_name
end else if is_var then
ret :: acc_vars, acc_funs
else
acc_vars, ret :: acc_funs
| None, _ -> acc_vars,acc_funs)
| _ -> acc_vars,acc_funs
) ([],[]) cl.cl_ordered_fields
in
(* let vars = List.rev vars in *)
(* let funs = List.rev funs in *)
(* see if there is any *)
(match vars, funs with
| [], [] -> ()
| _ ->
(* if there is, we need to find the constructor *)
let ctors = match cl.cl_constructor with
| Some ctor -> ctor
| None -> try
let sctor, sup, stl = OverloadingConstructor.prev_ctor cl (List.map snd cl.cl_params) in
let ctor = OverloadingConstructor.clone_ctors gen sctor sup stl cl in
cl.cl_constructor <- Some ctor;
ctor
with | Not_found ->
let basic = gen.gcon.basic in
let ctor = mk_class_field "new" (TFun([], basic.tvoid)) false cl.cl_pos (Method MethNormal) [] in
ctor.cf_expr <- Some
{
eexpr = TFunction {
tf_args = [];
tf_type = basic.tvoid;
tf_expr = { eexpr = TBlock[]; etype = basic.tvoid; epos = cl.cl_pos };
};
etype = ctor.cf_type;
epos = ctor.cf_pos;
};
cl.cl_constructor <- Some ctor;
ctor
in
let process ctor =
let func = match ctor.cf_expr with
| Some({eexpr = TFunction(tf)} as e) ->
let rec add_fn e = match e.eexpr with
| TBlock(hd :: tl) -> (match hd.eexpr with
| TCall({ eexpr = TConst TSuper }, _) ->
if not (OverloadingConstructor.descends_from_native_or_skipctor cl) then
{ e with eexpr = TBlock(vars @ (hd :: (funs @ tl))) }
else
{ e with eexpr = TBlock(hd :: (vars @ funs @ tl)) }
| TBlock(_) ->
{ e with eexpr = TBlock( (add_fn hd) :: tl ) }
| _ ->
{ e with eexpr = TBlock( vars @ funs @ (hd :: tl) ) })
| _ -> Type.concat { e with eexpr = TBlock(vars @ funs) } e
in
let tf_expr = add_fn (mk_block tf.tf_expr) in
{ e with eexpr = TFunction({ tf with tf_expr = tf_expr }) }
| _ -> assert false
in
ctor.cf_expr <- Some(func)
in
List.iter process (ctors :: ctors.cf_overloads)
)
end
in
let mod_filter = function
| TClassDecl cl -> (if not cl.cl_extern then handle_class cl); None
| _ -> None in
gen.gmodule_filters#add ~name:"init_funcs" ~priority:(PCustom priority) mod_filter
end;;
(* ******************************************* *)
(* Dynamic Binop/Unop handler *)
(* ******************************************* *)
(*
On some languages there is limited support for operations on
dynamic variables, so those operations must be changed.
There are 5 types of binary operators:
1 - can take any variable and returns a bool (== and !=)
2 - can take either a string, or a number and returns either a bool or the underlying type ( >, < for bool and + for returning its type)
3 - take numbers and return a number ( *, /, ...)
4 - take ints and return an int (bit manipulation)
5 - take a bool and returns a bool ( &&, || ...)
On the default implementation, type 1 and the plus function will be handled with a function call;
Type 2 will be handled with the parameter "compare_handler", which will do something like Reflect.compare(x1, x2);
Types 3, 4 and 5 will perform a cast to double, int and bool, which will then be handled normally by the platform
Unary operators are the most difficult to handle correctly.
With unary operators, there are 2 types:
1 - can take a number, changes and returns the result (++, --, ~)
2 - can take a number (-) or bool (!), and returns the result
The first case is much trickier, because it doesn't seem a good idea to change any variable to double just because it is dynamic,
but this is how we will handle right now.
something like that:
var x:Dynamic = 10;
x++;
will be:
object x = 10;
x = ((IConvertible)x).ToDouble(null) + 1;
depends on:
(syntax) must run before expression/statment normalization because it may generate complex expressions
must run before OverloadingCtor due to later priority conflicts. Since ExpressionUnwrap is only
defined afterwards, we will set this value with absolute values
*)
module DynamicOperators =
struct
let name = "dyn_ops"
let priority = 0.0
let priority_as_synf = 100.0 (*solve_deps name [DBefore ExpressionUnwrap.priority]*)
let abstract_implementation gen ?(handle_strings = true) (should_change:texpr->bool) (equals_handler:texpr->texpr->texpr) (dyn_plus_handler:texpr->texpr->texpr->texpr) (compare_handler:texpr->texpr->texpr) =
let get_etype_one e =
if like_int e.etype then
(gen.gcon.basic.tint, { eexpr = TConst(TInt(Int32.one)); etype = gen.gcon.basic.tint; epos = e.epos })
else
(gen.gcon.basic.tfloat, { eexpr = TConst(TFloat("1.0")); etype = gen.gcon.basic.tfloat; epos = e.epos })
in
let basic = gen.gcon.basic in
let rec run e =
match e.eexpr with
| TBinop (OpAssignOp op, e1, e2) when should_change e -> (* e1 will never contain another TBinop *)
(match e1.eexpr with
| TLocal _ ->
mk_paren { e with eexpr = TBinop(OpAssign, e1, run { e with eexpr = TBinop(op, e1, e2) }) }
| TField _ | TArray _ ->
let eleft, rest = match e1.eexpr with
| TField(ef, f) ->
let v = mk_temp gen "dynop" ef.etype in
{ e1 with eexpr = TField(mk_local v ef.epos, f) }, [ { eexpr = TVar(v,Some (run ef)); etype = basic.tvoid; epos = ef.epos } ]
| TArray(e1a, e2a) ->
let v = mk_temp gen "dynop" e1a.etype in
let v2 = mk_temp gen "dynopi" e2a.etype in
{ e1 with eexpr = TArray(mk_local v e1a.epos, mk_local v2 e2a.epos) }, [
{ eexpr = TVar(v,Some (run e1a)); etype = basic.tvoid; epos = e1.epos };
{ eexpr = TVar(v2, Some (run e2a)); etype = basic.tvoid; epos = e1.epos }
]
| _ -> assert false
in
{ e with
eexpr = TBlock (rest @ [ { e with eexpr = TBinop(OpAssign, eleft, run { e with eexpr = TBinop(op, eleft, e2) }) } ]);
}
| _ ->
assert false
)
| TBinop (OpAssign, e1, e2)
| TBinop (OpInterval, e1, e2) -> Type.map_expr run e
| TBinop (op, e1, e2) when should_change e->
(match op with
| OpEq -> (* type 1 *)
equals_handler (run e1) (run e2)
| OpNotEq -> (* != -> !equals() *)
mk_paren { eexpr = TUnop(Ast.Not, Prefix, (equals_handler (run e1) (run e2))); etype = gen.gcon.basic.tbool; epos = e.epos }
| OpAdd ->
if handle_strings && (is_string e.etype || is_string e1.etype || is_string e2.etype) then
{ e with eexpr = TBinop(op, mk_cast gen.gcon.basic.tstring (run e1), mk_cast gen.gcon.basic.tstring (run e2)) }
else
dyn_plus_handler e (run e1) (run e2)
| OpGt | OpGte | OpLt | OpLte -> (* type 2 *)
{ eexpr = TBinop(op, compare_handler (run e1) (run e2), { eexpr = TConst(TInt(Int32.zero)); etype = gen.gcon.basic.tint; epos = e.epos} ); etype = gen.gcon.basic.tbool; epos = e.epos }
| OpMult | OpDiv | OpSub | OpMod -> (* always cast everything to double *)
let etype, _ = get_etype_one e in
{ e with eexpr = TBinop(op, mk_cast etype (run e1), mk_cast etype (run e2)) }
| OpBoolAnd | OpBoolOr ->
{ e with eexpr = TBinop(op, mk_cast gen.gcon.basic.tbool (run e1), mk_cast gen.gcon.basic.tbool (run e2)) }
| OpAnd | OpOr | OpXor | OpShl | OpShr | OpUShr ->
{ e with eexpr = TBinop(op, mk_cast gen.gcon.basic.tint (run e1), mk_cast gen.gcon.basic.tint (run e2)) }
| OpAssign | OpAssignOp _ | OpInterval | OpArrow -> assert false)
| TUnop (Increment as op, flag, e1)
| TUnop (Decrement as op, flag, e1) when should_change e ->
(*
some naming definitions:
* ret => the returning variable
* _g => the get body
* getvar => the get variable expr
This will work like this:
- if e1 is a TField, set _g = get body, getvar = (get body).varname
- if Prefix, return getvar = getvar + 1.0
- if Postfix, set ret = getvar; getvar = getvar + 1.0; ret;
*)
let etype, one = get_etype_one e in
let op = (match op with Increment -> OpAdd | Decrement -> OpSub | _ -> assert false) in
let var, getvar =
match e1.eexpr with
| TField(fexpr, field) ->
let tmp = mk_temp gen "getvar" fexpr.etype in
let var = { eexpr = TVar(tmp, Some(run fexpr)); etype = gen.gcon.basic.tvoid; epos = e.epos } in
(Some var, { eexpr = TField( { fexpr with eexpr = TLocal(tmp) }, field); etype = etype; epos = e1.epos })
| _ ->
(None, e1)
in
(match flag with
| Prefix ->
let block = (match var with | Some e -> [e] | None -> []) @
[
mk_cast etype { e with eexpr = TBinop(OpAssign, getvar,{ eexpr = TBinop(op, mk_cast etype getvar, one); etype = etype; epos = e.epos }); etype = getvar.etype; }
]
in
{ eexpr = TBlock(block); etype = etype; epos = e.epos }
| Postfix ->
let ret = mk_temp gen "ret" etype in
let vars = (match var with Some e -> [e] | None -> []) @ [{ eexpr = TVar(ret, Some (mk_cast etype getvar)); etype = gen.gcon.basic.tvoid; epos = e.epos }] in
let retlocal = { eexpr = TLocal(ret); etype = etype; epos = e.epos } in
let block = vars @
[
{ e with eexpr = TBinop(OpAssign, getvar, { eexpr = TBinop(op, retlocal, one); etype = getvar.etype; epos = e.epos }) };
retlocal
] in
{ eexpr = TBlock(block); etype = etype; epos = e.epos }
)
| TUnop (op, flag, e1) when should_change e ->
let etype = match op with | Not -> gen.gcon.basic.tbool | _ -> gen.gcon.basic.tint in
mk_paren { eexpr = TUnop(op, flag, mk_cast etype (run e1)); etype = etype; epos = e.epos }
| _ -> Type.map_expr run e
in
run
let configure gen (mapping_func:texpr->texpr) =
let map e = Some(mapping_func e) in
gen.gexpr_filters#add ~name:"dyn_ops" ~priority:(PCustom priority) map
let configure_as_synf gen (mapping_func:texpr->texpr) =
let map e = Some(mapping_func e) in
gen.gexpr_filters#add ~name:"dyn_ops" ~priority:(PCustom priority_as_synf) map
end;;
(* ******************************************* *)
(* Dynamic Field Access *)
(* ******************************************* *)
(*
This module will filter every dynamic field access in haxe.
On platforms that do not support dynamic access, it is with this that you should
replace dynamic calls with x.field / Reflect.setField calls, and guess what -
this is the default implemenation!
Actually there is a problem with Reflect.setField because it returns void, which is a bad thing for us,
so even in the default implementation, the function call should be specified to a Reflect.setField version that returns
the value that was set
(TODO: should it be separated?)
As a plus, the default implementation adds something that doesn't hurt anybody, it looks for
TAnon with Statics / EnumStatics field accesses and transforms them into real static calls.
This means it will take this
var m = Math;
for (i in 0...1000) m.cos(10);
which is an optimization in dynamic platforms, but performs horribly on strongly typed platforms
and transform into:
var m = Math;
for (i in 0...1000) Math.cos(10);
(addendum:)
configure_generate_classes will already take care of generating the reflection-enabled class fields and calling abstract_implementation
with the right arguments.
Also
depends on:
(ok) must run AFTER Binop/Unop handler - so Unops / Binops are already unrolled
*)
module DynamicFieldAccess =
struct
let name = "dynamic_field_access"
let priority = solve_deps name [DAfter DynamicOperators.priority]
let priority_as_synf = solve_deps name [DAfter DynamicOperators.priority_as_synf]
(*
is_dynamic (expr) (field_access_expr) (field) : a function that indicates if the field access should be changed
change_expr (expr) (field_access_expr) (field) (setting expr) (is_unsafe) : changes the expression
call_expr (expr) (field_access_expr) (field) (call_params) : changes a call expression
*)
let abstract_implementation gen (is_dynamic:texpr->texpr->Type.tfield_access->bool) (change_expr:texpr->texpr->string->texpr option->bool->texpr) (call_expr:texpr->texpr->string->texpr list->texpr) =
let rec run e =
match e.eexpr with
(* class types *)
| TField(fexpr, f) when is_some (anon_class fexpr.etype) ->
let decl = get (anon_class fexpr.etype) in
let name = field_name f in
(try
match decl with
| TClassDecl cl ->
let cf = PMap.find name cl.cl_statics in
{ e with eexpr = TField({ fexpr with eexpr = TTypeExpr decl }, FStatic(cl, cf)) }
| TEnumDecl en ->
let ef = PMap.find name en.e_constrs in
{ e with eexpr = TField({ fexpr with eexpr = TTypeExpr decl }, FEnum(en, ef)) }
| TAbstractDecl _ -> (* abstracts don't have TFields *) assert false
| TTypeDecl _ -> (* anon_class doesn't return TTypeDecl *) assert false
with
| Not_found -> match f with
| FStatic(cl,cf) when Meta.has Meta.Extern cf.cf_meta ->
{ e with eexpr = TField({ fexpr with eexpr = TTypeExpr decl }, FStatic(cl, cf)) }
| _ ->
change_expr e { fexpr with eexpr = TTypeExpr decl } (field_name f) None true
)
| TField(fexpr, f) when is_dynamic e fexpr (f) ->
change_expr e (run fexpr) (field_name f) None true
| TCall(
{ eexpr = TField(_, FStatic({ cl_path = ([], "Reflect") }, { cf_name = "field" })) } ,
[obj; { eexpr = TConst(TString(field)) }]
) ->
let t = match gen.greal_type obj.etype with
| TDynamic _ | TAnon _ | TMono _ -> t_dynamic
| t -> t
in
change_expr (mk_field_access gen { obj with etype = t } field obj.epos) (run obj) field None false
| TCall(
{ eexpr = TField(_, FStatic({ cl_path = ([], "Reflect") }, { cf_name = "setField" } )) },
[obj; { eexpr = TConst(TString(field)) }; evalue]
) ->
change_expr (mk_field_access gen obj field obj.epos) (run obj) field (Some (run evalue)) false
| TBinop(OpAssign, ({eexpr = TField(fexpr, f)}), evalue) when is_dynamic e fexpr (f) ->
change_expr e (run fexpr) (field_name f) (Some (run evalue)) true
| TBinop(OpAssign, { eexpr = TField(fexpr, f) }, evalue) ->
(match field_access_esp gen fexpr.etype (f) with
| FClassField(_,_,_,cf,false,t,_) when (try PMap.find cf.cf_name gen.gbase_class_fields == cf with Not_found -> false) ->
change_expr e (run fexpr) (field_name f) (Some (run evalue)) true
| _ -> Type.map_expr run e
)
(* #if debug *)
| TBinop(OpAssignOp op, ({eexpr = TField(fexpr, f)}), evalue) when is_dynamic e fexpr (f) -> assert false (* this case shouldn't happen *)
| TUnop(Increment, _, ({eexpr = TField( ( { eexpr=TLocal(local) } as fexpr ), f)}))
| TUnop(Decrement, _, ({eexpr = TField( ( { eexpr=TLocal(local) } as fexpr ), f)})) when is_dynamic e fexpr (f) -> assert false (* this case shouldn't happen *)
(* #end *)
| TCall( ({ eexpr = TField(fexpr, f) }), params ) when is_dynamic e fexpr (f) ->
call_expr e (run fexpr) (field_name f) (List.map run params)
| _ -> Type.map_expr run e
in run
(*
this function will already configure with the abstract implementation, and also will create the needed class fields to
enable reflection on platforms that don't support reflection.
this means it will create the following class methods:
- getField(field, isStatic) - gets the value of the field. isStatic
- setField -
-
*)
let configure_generate_classes gen optimize (runtime_getset_field:texpr->texpr->string->texpr option->texpr) (runtime_call_expr:texpr->texpr->string->texpr list->texpr) =
()
let configure gen (mapping_func:texpr->texpr) =
let map e = Some(mapping_func e) in
gen.gexpr_filters#add ~name:"dynamic_field_access" ~priority:(PCustom(priority)) map
let configure_as_synf gen (mapping_func:texpr->texpr) =
let map e = Some(mapping_func e) in
gen.gexpr_filters#add ~name:"dynamic_field_access" ~priority:(PCustom(priority_as_synf)) map
end;;
(* ******************************************* *)
(* Closure Detection *)
(* ******************************************* *)
(*
Just a small utility filter that detects when a closure must be created.
On the default implementation, this means when a function field is being accessed
not via reflection and not to be called instantly
dependencies:
must run after DynamicFieldAccess, so any TAnon { Statics / EnumStatics } will be changed to the corresponding TTypeExpr
*)
module FilterClosures =
struct
let name = "filter_closures"
let priority = solve_deps name [DAfter DynamicFieldAccess.priority]
let traverse gen (should_change:texpr->string->bool) (filter:texpr->texpr->string->bool->texpr) =
let rec run e =
match e.eexpr with
(*(* this is precisely the only case where we won't even ask if we should change, because it is a direct use of TClosure *)
| TCall ( {eexpr = TClosure(e1,s)} as clos, args ) ->
{ e with eexpr = TCall({ clos with eexpr = TClosure(run e1, s) }, List.map run args ) }
| TCall ( clos, args ) ->
let rec loop clos = match clos.eexpr with
| TClosure(e1,s) -> Some (clos, e1, s)
| TParenthesis p -> loop p
| _ -> None
in
let clos = loop clos in
(match clos with
| Some (clos, e1, s) -> { e with eexpr = TCall({ clos with eexpr = TClosure(run e1, s) }, List.map run args ) }
| None -> Type.map_expr run e)*)
| TCall({ eexpr = TLocal{ v_name = "__delegate__" } } as local, [del]) ->
{ e with eexpr = TCall(local, [Type.map_expr run del]) }
| TCall(({ eexpr = TField(_, _) } as ef), params) ->
{ e with eexpr = TCall(Type.map_expr run ef, List.map run params) }
| TField(ef, FEnum(en, field)) ->
(* FIXME replace t_dynamic with actual enum Anon field *)
let ef = run ef in
(match follow field.ef_type with
| TFun _ when should_change ef field.ef_name ->
filter e ef field.ef_name true
| _ ->
{ e with eexpr = TField(ef, FEnum(en,field)) }
)
| TField(({ eexpr = TTypeExpr _ } as tf), f) ->
(match field_access_esp gen tf.etype (f) with
| FClassField(_,_,_,cf,_,_,_) ->
(match cf.cf_kind with
| Method(MethDynamic)
| Var _ ->
e
| _ when should_change tf cf.cf_name ->
filter e tf cf.cf_name true
| _ ->
e
)
| _ -> e)
| TField(e1, FClosure (Some _, cf)) when should_change e1 cf.cf_name ->
(match cf.cf_kind with
| Method MethDynamic | Var _ ->
Type.map_expr run e
| _ ->
filter e (run e1) cf.cf_name false)
| _ -> Type.map_expr run e
in
run
let configure gen (mapping_func:texpr->texpr) =
let map e = Some(mapping_func e) in
gen.gexpr_filters#add ~name:name ~priority:(PCustom priority) map
end;;
(* ******************************************* *)
(* Dynamic TArray Handling *)
(* ******************************************* *)
(*
In some languages you cannot overload the [] operator,
so we need to decide what is kept as TArray and what gets mapped.
- in order to do this you must ensure that
depends on:
(syntax) must run before expression/statment normalization because it may generate complex expressions
(ok) must run before binop transformations because it may generate some untreated binop ops
(ok) must run before dynamic field access is transformed into reflection
*)
module TArrayTransform =
struct
let name = "dyn_tarray"
let priority = solve_deps name [DBefore DynamicOperators.priority; DBefore DynamicFieldAccess.priority]
let priority_as_synf = solve_deps name [DBefore DynamicOperators.priority_as_synf; DBefore DynamicFieldAccess.priority_as_synf]
(* should change signature: tarray expr -> binop operation -> should change? *)
let default_implementation gen (should_change:texpr->Ast.binop option->bool) (get_fun:string) (set_fun:string) =
let basic = gen.gcon.basic in
let mk_get e e1 e2 =
let efield = mk_field_access gen e1 get_fun e.epos in
{ e with eexpr = TCall(efield, [e2]) }
in
let mk_set e e1 e2 evalue =
let efield = mk_field_access gen e1 set_fun e.epos in
{ e with eexpr = TCall(efield, [e2; evalue]) }
in
let rec run e =
match e.eexpr with
| TArray(e1, e2) ->
(* e1 should always be a var; no need to map there *)
if should_change e None then mk_get e (run e1) (run e2) else Type.map_expr run e
| TBinop (Ast.OpAssign, ({ eexpr = TArray(e1a,e2a) } as earray), evalue) when should_change earray (Some Ast.OpAssign) ->
mk_set e (run e1a) (run e2a) (run evalue)
| TBinop (Ast.OpAssignOp op,({ eexpr = TArray(e1a,e2a) } as earray) , evalue) when should_change earray (Some (Ast.OpAssignOp op)) ->
(* cache all arguments in vars so they don't get executed twice *)
(* let ensure_local gen block name e = *)
let block = ref [] in
let arr_local = ensure_local gen block "array" (run e1a) in
let idx_local = ensure_local gen block "index" (run e2a) in
block := (mk_set e arr_local idx_local ( { e with eexpr=TBinop(op, mk_get earray arr_local idx_local, run evalue) } )) :: !block;
{ e with eexpr = TBlock (List.rev !block) }
| TUnop(op, flag, ({ eexpr = TArray(e1a, e2a) } as earray)) ->
if should_change earray None && match op with | Not | Neg -> false | _ -> true then begin
let block = ref [] in
let actual_t = match op with
| Ast.Increment | Ast.Decrement -> (match follow earray.etype with
| TInst _ | TAbstract _ | TEnum _ -> earray.etype
| _ -> basic.tfloat)
| Ast.Not -> basic.tbool
| _ -> basic.tint
in
let val_v = mk_temp gen "arrVal" actual_t in
let ret_v = mk_temp gen "arrRet" actual_t in
let arr_local = ensure_local gen block "arr" (run e1a) in
let idx_local = ensure_local gen block "arrIndex" (run e2a) in
let val_local = { earray with eexpr = TLocal(val_v) } in
let ret_local = { earray with eexpr = TLocal(ret_v) } in
(* var idx = 1; var val = x._get(idx); var ret = val++; x._set(idx, val); ret; *)
block := { eexpr = TVar(val_v, Some(mk_get earray arr_local idx_local)); (* var val = x._get(idx) *)
etype = gen.gcon.basic.tvoid;
epos = e2a.epos
} :: !block;
block := { eexpr = TVar(ret_v, Some { e with eexpr = TUnop(op, flag, val_local) }); (* var ret = val++ *)
etype = gen.gcon.basic.tvoid;
epos = e2a.epos
} :: !block;
block := (mk_set e arr_local idx_local val_local) (*x._set(idx,val)*) :: !block;
block := ret_local :: !block;
{ e with eexpr = TBlock (List.rev !block) }
end else
Type.map_expr run e
| _ -> Type.map_expr run e
in run
let configure gen (mapping_func:texpr->texpr) =
let map e = Some(mapping_func e) in
gen.gexpr_filters#add ~name:"dyn_tarray" ~priority:(PCustom priority) map
let configure_as_synf gen (mapping_func:texpr->texpr) =
let map e = Some(mapping_func e) in
gen.gexpr_filters#add ~name:"dyn_tarray" ~priority:(PCustom priority_as_synf) map
end;;
(* ******************************************* *)
(* Try / Catch + throw native types handling *)
(* ******************************************* *)
(*
Some languages/vm's do not support throwing any kind of value. For them, only
special kinds of objects can be thrown. Because of this, we must wrap some throw
statements with an expression, and also we must unwrap it on the catch() phase, and
maybe manually test with Std.is()
dependencies:
must run before dynamic field access (?) TODO review
It's a syntax filter, as it alters types (throw wrapper)
*)
module TryCatchWrapper =
struct
let priority = solve_deps "try_catch" [DBefore DynamicFieldAccess.priority]
(*
should_wrap : does the type should be wrapped? This of course works on the reverse way, so it tells us if the type should be unwrapped as well
wrap_throw : the wrapper for throw (throw expr->expr inside throw->returning wrapped expression)
unwrap_expr : the other way around : given the catch var (maybe will need casting to wrapper_type) , return the unwrap expr
rethrow_expr : how to rethrow ane exception in the platform
catchall_type : the class used for catchall (e:Dynamic)
wrapper_type : the wrapper type, so we can test if exception is of type 'wrapper'
catch_map : maps the catch expression to include some intialization code (e.g. setting up Stack.exceptionStack)
*)
let traverse gen (should_wrap:t->bool) (wrap_throw:texpr->texpr->texpr) (unwrap_expr:tvar->pos->texpr) (rethrow_expr:texpr->texpr) (catchall_type:t) (wrapper_type:t) (catch_map:tvar->texpr->texpr) =
let rec run e =
match e.eexpr with
| TThrow texpr when should_wrap texpr.etype -> wrap_throw e (run texpr)
| TTry (ttry, catches) ->
let nowrap_catches, must_wrap_catches, catchall = List.fold_left (fun (nowrap_catches, must_wrap_catches, catchall) (v, catch) ->
(* first we'll see if the type is Dynamic (catchall) *)
match follow v.v_type with
| TDynamic _ ->
assert (is_none catchall);
(nowrap_catches, must_wrap_catches, Some(v,run catch))
(* see if we should unwrap it *)
| _ when should_wrap (follow v.v_type) ->
(nowrap_catches, (v,run catch) :: must_wrap_catches, catchall)
| _ ->
( (v,catch_map v (run catch)) :: nowrap_catches, must_wrap_catches, catchall )
) ([], [], None) catches
in
(* temp (?) fix for https://github.com/HaxeFoundation/haxe/issues/4134 *)
let must_wrap_catches = List.rev must_wrap_catches in
(*
1st catch all nowrap "the easy way"
2nd see if there are any must_wrap or catchall. If there is,
do a catchall first with a temp var.
then get catchall var (as dynamic) (or create one), and declare it = catchall exception
then test if it is of type wrapper_type. If it is, unwrap it
then start doing Std.is() tests for each catch type
if there is a catchall in the end, end with it. If there isn't, rethrow
*)
let dyn_catch = match (catchall, must_wrap_catches) with
| Some (v,c), _
| _, (v, c) :: _ ->
let pos = c.epos in
let temp_var = mk_temp gen "catchallException" catchall_type in
let temp_local = { eexpr=TLocal(temp_var); etype = temp_var.v_type; epos = pos } in
let catchall_var = (*match catchall with
| None -> *) mk_temp gen "catchall" t_dynamic
(*| Some (v,_) -> v*)
in
let catchall_decl = { eexpr = TVar(catchall_var, Some(temp_local)); etype=gen.gcon.basic.tvoid; epos = pos } in
let catchall_local = { eexpr = TLocal(catchall_var); etype = t_dynamic; epos = pos } in
(* if it is of type wrapper_type, unwrap it *)
let std_is = mk_static_field_access (get_cl (get_type gen ([],"Std"))) "is" (TFun(["v",false,t_dynamic;"cl",false,mt_to_t (get_type gen ([], "Class")) [t_dynamic]],gen.gcon.basic.tbool)) pos in
let mk_std_is t pos = { eexpr = TCall(std_is, [catchall_local; mk_mt_access (t_to_mt t) pos]); etype = gen.gcon.basic.tbool; epos = pos } in
let if_is_wrapper_expr = { eexpr = TIf(mk_std_is wrapper_type pos,
{ eexpr = TBinop(OpAssign, catchall_local, unwrap_expr temp_var pos); etype = t_dynamic; epos = pos }
, None); etype = gen.gcon.basic.tvoid; epos = pos } in
let rec loop must_wrap_catches = match must_wrap_catches with
| (vcatch,catch) :: tl ->
{ eexpr = TIf(mk_std_is vcatch.v_type catch.epos,
{ eexpr = TBlock({ eexpr=TVar(vcatch, Some(mk_cast vcatch.v_type catchall_local)); etype=gen.gcon.basic.tvoid; epos=catch.epos } :: [catch] ); etype = catch.etype; epos = catch.epos },
Some (loop tl));
etype = catch.etype; epos = catch.epos }
| [] ->
match catchall with
| Some (v,s) ->
Type.concat { eexpr = TVar(v, Some(catchall_local)); etype = gen.gcon.basic.tvoid; epos = pos } s
| None ->
mk_block (rethrow_expr temp_local)
in
[ ( temp_var, catch_map temp_var { e with eexpr = TBlock([ catchall_decl; if_is_wrapper_expr; loop must_wrap_catches ]) } ) ]
| _ ->
[]
in
{ e with eexpr = TTry(run ttry, (List.rev nowrap_catches) @ dyn_catch) }
| _ -> Type.map_expr run e
in
run
let configure gen (mapping_func:texpr->texpr) =
let map e = Some(mapping_func e) in
gen.gsyntax_filters#add ~name:"try_catch" ~priority:(PCustom priority) map
end;;
let fun_args = List.map (function | (v,s) -> (v.v_name, (match s with | None -> false | Some _ -> true), v.v_type))
(* ******************************************* *)
(* Closures To Class *)
(* ******************************************* *)
(*
This is a very important filter. It will take all anonymous functions from the AST, will search for all captured variables, and will create a class
that implements an abstract interface for calling functions. This is very important for targets that don't support anonymous functions to work correctly.
Also it is possible to implement some strategies to avoid value type boxing, such as NaN tagging or double/object arguments. All this will be abstracted away
from this interface.
dependencies:
must run after dynamic field access, because of conflicting ways to deal with invokeField
(module filter) must run after OverloadingCtor so we can also change the dynamic function expressions
uses TArray expressions for array. TODO see interaction
uses TThrow expressions.
*)
module ClosuresToClass =
struct
let name = "closures_to_class"
let priority = solve_deps name [ DAfter DynamicFieldAccess.priority ]
let priority_as_synf = solve_deps name [ DAfter DynamicFieldAccess.priority_as_synf ]
type closures_ctx =
{
fgen : generator_ctx;
mutable func_class : tclass;
(*
this is what will actually turn the function into class field.
The standard implementation by default will already take care of creating the class, and setting the captured variables.
It will also return the super arguments to be called
*)
mutable closure_to_classfield : tfunc->t->pos->tclass_field * (texpr list);
(*
when a dynamic function call is made, we need to convert it as if it were calling the dynamic function interface.
TCall expr -> new TCall expr
*)
mutable dynamic_fun_call : texpr->texpr;
(*
called once so the implementation can make one of a time initializations in the base class
for all functions
*)
mutable initialize_base_class : tclass->unit;
(*
Base classfields are the class fields for the abstract implementation of either the Function implementation,
or the invokeField implementation for the classes
They will either try to call the right function or will fail with
(tclass - subject (so we know the type of this)) -> is_function_base -> additional arguments for each function (at the beginning) -> list of the abstract implementation class fields
*)
mutable get_base_classfields_for : tclass->bool->(unit->(tvar * tconstant option) list)->tclass_field list;
(*
This is a more complex version of get_base_classfields_for.
It's meant to provide a toolchain so we can easily create classes that extend Function
and add more functionality on top of it.
arguments:
tclass -> subject (so we know the type of this)
bool -> is it a function type
( int -> (int->t->tconstant option->texpr) -> ( (tvar * tconstant option) list * texpr) )
int -> current arity of the function whose member will be mapped; -1 for dynamic function. It is guaranteed that dynamic function will be called last
t -> the return type of the function
(int->t->tconstant option->texpr) -> api to get exprs that unwrap arguments correctly
int -> argument wanted to unwrap
t -> solicited type
tconstant option -> map to this default value if null
returns a texpr that tells how the default
should return a list with additional arguments (only works if is_function_base = true)
and the underlying function expression
*)
mutable map_base_classfields : tclass->bool->( int -> t -> (tvar list) -> (int->t->tconstant option->texpr) -> ( (tvar * tconstant option) list * texpr) )->tclass_field list;
mutable transform_closure : texpr->texpr->string->texpr;
}
type map_info = {
in_unsafe : bool;
in_unused : bool;
}
let null_map_info = { in_unsafe = false; in_unused = false; }
(*
the default implementation will take 3 transformation functions:
* one that will transform closures that are not called immediately (instance.myFunc).
normally on this case it's best to have a runtime handler that will take the instance, the function and call its invokeField when invoked
* one that will actually handle the anonymous functions themselves.
* one that will transform calling a dynamic function. So for example, dynFunc(arg1, arg2) might turn into dynFunc.apply2(arg1, arg2);
( suspended ) * an option to match papplied functions
* handling parameterized anonymous function declaration (optional - tparam_anon_decl and tparam_anon_acc)
*)
let rec cleanup_delegate e = match e.eexpr with
| TParenthesis e | TMeta(_,e)
| TCast(e,_) -> cleanup_delegate e
| _ -> e
let funct gen t = match follow (run_follow gen t) with
| TFun(args,ret) -> args,ret
| _ -> raise Not_found
let mk_conversion_fun gen e =
let args, ret = funct gen e.etype in
let tf_args = List.map (fun (n,o,t) -> alloc_var n t,None) args in
let block, local = match e.eexpr with
| TLocal v ->
v.v_capture <- true;
[],e
| _ ->
let tmp = mk_temp gen "delegate_conv" e.etype in
tmp.v_capture <- true;
[{ eexpr = TVar(tmp,Some e); etype = gen.gcon.basic.tvoid; epos = e.epos }], mk_local tmp e.epos
in
let body = {
eexpr = TCall(local, List.map (fun (v,_) -> mk_local v e.epos) tf_args);
etype = ret;
epos = e.epos;
} in
let body = if not (is_void ret) then
{ body with eexpr = TReturn( Some body ) }
else
body
in
let body = {
eexpr = TBlock(block @ [body]);
etype = body.etype;
epos = body.epos;
} in
{
tf_args = tf_args;
tf_expr = body;
tf_type = ret;
}
let traverse gen ?tparam_anon_decl ?tparam_anon_acc (transform_closure:texpr->texpr->string->texpr) (handle_anon_func:texpr->tfunc->map_info->t option->texpr) (dynamic_func_call:texpr->texpr) e =
let info = ref null_map_info in
let rec run e =
match e.eexpr with
| TCast({ eexpr = TCall({ eexpr = TLocal{ v_name = "__delegate__" } } as local, [del] ) } as e2, _) ->
let e2 = { e2 with etype = e.etype } in
let replace_delegate ex =
{ e with eexpr = TCast({ e2 with eexpr = TCall(local, [ex]) }, None) }
in
(* found a delegate; let's see if it's a closure or not *)
let clean = cleanup_delegate del in
(match clean.eexpr with
| TField( ef, (FClosure _ as f)) | TField( ef, (FStatic _ as f)) ->
(* a closure; let's leave this unchanged for FilterClosures to handle it *)
replace_delegate { clean with eexpr = TField( run ef, f ) }
| TFunction tf ->
(* handle like we'd handle a normal function, but create an unchanged closure field for it *)
let ret = handle_anon_func clean { tf with tf_expr = run tf.tf_expr } !info (Some e.etype) in
replace_delegate ret
| _ -> try
let tf = mk_conversion_fun gen del in
let ret = handle_anon_func del { tf with tf_expr = run tf.tf_expr } !info (Some e.etype) in
replace_delegate ret
with Not_found ->
gen.gcon.error "This delegate construct is unsupported" e.epos;
replace_delegate (run clean))
| TCall(({ eexpr = TLocal{ v_name = "__unsafe__" } } as local), [arg]) ->
let old = !info in
info := { !info with in_unsafe = true };
let arg2 = run arg in
info := old;
{ e with eexpr = TCall(local,[arg2]) }
(* parameterized functions handling *)
| TVar(vv, ve) -> (match tparam_anon_decl with
| None -> Type.map_expr run e
| Some tparam_anon_decl ->
(match (vv, ve) with
| ({ v_extra = Some( _ :: _, _) } as v), Some ({ eexpr = TFunction tf } as f)
| ({ v_extra = Some( _ :: _, _) } as v), Some { eexpr = TArrayDecl([{ eexpr = TFunction tf } as f]) | TCall({ eexpr = TLocal { v_name = "__array__" } }, [{ eexpr = TFunction tf } as f]) } -> (* captured transformation *)
ignore(tparam_anon_decl v f { tf with tf_expr = run tf.tf_expr });
{ e with eexpr = TBlock([]) }
| _ ->
Type.map_expr run { e with eexpr = TVar(vv, ve) })
)
| TLocal ({ v_extra = Some( _ :: _, _) } as v)
| TArray ({ eexpr = TLocal ({ v_extra = Some( _ :: _, _) } as v) }, _) -> (* captured transformation *)
(match tparam_anon_acc with
| None -> Type.map_expr run e
| Some tparam_anon_acc -> tparam_anon_acc v e)
| TCall( { eexpr = TField(_, FEnum _) }, _ ) ->
Type.map_expr run e
(* if a TClosure is being call immediately, there's no need to convert it to a TClosure *)
| TCall(( { eexpr = TField(ecl,f) } as e1), params) ->
(* check to see if called field is known and if it is a MethNormal (only MethNormal fields can be called directly) *)
(* let name = field_name f in *)
(match field_access_esp gen (gen.greal_type ecl.etype) f with
| FClassField(_,_,_,cf,_,_,_) ->
(match cf.cf_kind with
| Method MethNormal
| Method MethInline ->
{ e with eexpr = TCall({ e1 with eexpr = TField(run ecl, f) }, List.map run params) }
| _ ->
match gen.gfollow#run_f e1.etype with
| TFun _ ->
dynamic_func_call { e with eexpr = TCall(run e1, List.map run params) }
| _ ->
let i = ref 0 in
let t = TFun(List.map (fun e -> incr i; "arg" ^ (string_of_int !i), false, e.etype) params, e.etype) in
dynamic_func_call { e with eexpr = TCall( mk_cast t (run e1), List.map run params ) }
)
(* | FNotFound ->
{ e with eexpr = TCall({ e1 with eexpr = TField(run ecl, f) }, List.map run params) }
(* expressions by now may have generated invalid expressions *) *)
| _ ->
match gen.gfollow#run_f e1.etype with
| TFun _ ->
dynamic_func_call { e with eexpr = TCall(run e1, List.map run params) }
| _ ->
let i = ref 0 in
let t = TFun(List.map (fun e -> incr i; "arg" ^ (string_of_int !i), false, e.etype) params, e.etype) in
dynamic_func_call { e with eexpr = TCall( mk_cast t (run e1), List.map run params ) }
)
| TField(ecl, FClosure (_,cf)) ->
transform_closure e (run ecl) cf.cf_name
| TFunction tf ->
handle_anon_func e { tf with tf_expr = run tf.tf_expr } !info None
| TCall({ eexpr = TConst(TSuper) }, _) ->
Type.map_expr run e
| TCall({ eexpr = TLocal(v) }, args) when String.get v.v_name 0 = '_' && Hashtbl.mem gen.gspecial_vars v.v_name ->
Type.map_expr run e
| TCall(tc,params) ->
let i = ref 0 in
let may_cast = match gen.gfollow#run_f tc.etype with
| TFun _ -> fun e -> e
| _ ->
let t = TFun(List.map (fun e ->
incr i;
("p" ^ (string_of_int !i), false, e.etype)
) params, e.etype)
in
fun e -> mk_cast t e
in
dynamic_func_call { e with eexpr = TCall(run (may_cast tc), List.map run params) }
| _ -> Type.map_expr run e
in
(match e.eexpr with
| TFunction(tf) -> Type.map_expr run e
| _ -> run e)
let rec get_type_params acc t =
match t with
| TInst(( { cl_kind = KTypeParameter _ } as cl), []) ->
if List.memq cl acc then acc else cl :: acc
| TFun (params,tret) ->
List.fold_left get_type_params acc ( tret :: List.map (fun (_,_,t) -> t) params )
| TDynamic t ->
(match t with | TDynamic _ -> acc | _ -> get_type_params acc t)
| TAbstract (a, pl) when not (Meta.has Meta.CoreType a.a_meta) ->
get_type_params acc ( Abstract.get_underlying_type a pl)
| TAnon a ->
PMap.fold (fun cf acc ->
let params = List.map (fun (_,t) -> match follow t with
| TInst(c,_) -> c
| _ -> assert false) cf.cf_params
in
List.filter (fun t -> not (List.memq t params)) (get_type_params acc cf.cf_type)
) a.a_fields acc
| TType(_, [])
| TAbstract (_, [])
| TInst(_, [])
| TEnum(_, []) ->
acc
| TType(_, params)
| TAbstract(_, params)
| TEnum(_, params)
| TInst(_, params) ->
List.fold_left get_type_params acc params
| TMono r -> (match !r with
| Some t -> get_type_params acc t
| None -> acc)
| _ -> get_type_params acc (follow_once t)
let get_captured expr =
let ret = Hashtbl.create 1 in
let ignored = Hashtbl.create 0 in
let params = ref [] in
let check_params t = params := get_type_params !params t in
let rec traverse expr =
match expr.eexpr with
| TFor (v, _, _) ->
Hashtbl.add ignored v.v_id v;
check_params v.v_type;
Type.iter traverse expr
| TFunction(tf) ->
List.iter (fun (v,_) -> Hashtbl.add ignored v.v_id v) tf.tf_args;
(match follow expr.etype with
| TFun(args,ret) ->
List.iter (fun (_,_,t) ->
check_params t
) args;
check_params ret
| _ -> ());
Type.iter traverse expr
| TVar (v, opt) ->
(match v.v_extra with
| Some(_ :: _, _) -> ()
| _ ->
check_params v.v_type);
Hashtbl.add ignored v.v_id v;
ignore(Option.map traverse opt)
| TLocal { v_extra = Some( (_ :: _ ),_) } ->
()
| TLocal(( { v_capture = true } ) as v) ->
(if not (Hashtbl.mem ignored v.v_id || Hashtbl.mem ret v.v_id) then begin check_params v.v_type; Hashtbl.replace ret v.v_id expr end);
| _ -> Type.iter traverse expr
in traverse expr;
ret, !params
(*
OPTIMIZEME:
Take off from Codegen the code that wraps captured variables,
traverse through all variables, looking for their use (just like local_usage)
three possible outcomes for captured variables:
- become a function member variable <- best performance.
Will not work on functions that can be created more than once (functions inside a loop or functions inside functions)
The function will have to be created on top of the block, so its variables can be filled in instead of being declared
- single-element array - the most compatible way, though also creates a slight overhead.
- we'll have some labels for captured variables:
- used in loop
*)
(*
The default implementation will impose a naming convention:
invoke(arity)_(o for returning object/d for returning double) when arity < max_arity
invoke_dynamic_(o/d) when arity > max_arity
This means that it also imposes that the dynamic function return types may only be Dynamic or Float, and all other basic types must be converted to/from it.
*)
let default_implementation ft parent_func_class (* e.g. new haxe.lang.ClassClosure *) =
let gen = ft.fgen in
ft.initialize_base_class parent_func_class;
let cfs = ft.get_base_classfields_for parent_func_class true (fun () -> []) in
List.iter (fun cf ->
(if cf.cf_name = "new" then parent_func_class.cl_constructor <- Some cf else
parent_func_class.cl_fields <- PMap.add cf.cf_name cf parent_func_class.cl_fields
)
) cfs;
parent_func_class.cl_ordered_fields <- (List.filter (fun cf -> cf.cf_name <> "new") cfs) @ parent_func_class.cl_ordered_fields;
ft.func_class <- parent_func_class;
let handle_anon_func fexpr tfunc mapinfo delegate_type : texpr * (tclass * texpr list) =
let gen = ft.fgen in
let in_unsafe = mapinfo.in_unsafe || match gen.gcurrent_class, gen.gcurrent_classfield with
| Some c, _ when Meta.has Meta.Unsafe c.cl_meta -> true
| _, Some cf when Meta.has Meta.Unsafe cf.cf_meta -> true
| _ -> false
in
(* get all captured variables it uses *)
let captured_ht, tparams = get_captured fexpr in
let captured = Hashtbl.fold (fun _ e acc -> e :: acc) captured_ht [] in
let captured = List.sort (fun e1 e2 -> match e1, e2 with
| { eexpr = TLocal v1 }, { eexpr = TLocal v2 } ->
compare v1.v_name v2.v_name
| _ -> assert false) captured
in
(*let cltypes = List.map (fun cl -> (snd cl.cl_path, TInst(map_param cl, []) )) tparams in*)
let cltypes = List.map (fun cl -> (snd cl.cl_path, TInst(cl, []) )) tparams in
(* create a new class that extends abstract function class, with a ctor implementation that will setup all captured variables *)
let cfield = match ft.fgen.gcurrent_classfield with
| None -> "Anon"
| Some cf -> cf.cf_name
in
let cur_line = Lexer.get_error_line fexpr.epos in
let path = (fst ft.fgen.gcurrent_path, Printf.sprintf "%s_%s_%d__Fun" (snd ft.fgen.gcurrent_path) cfield cur_line) in
let cls = mk_class (get ft.fgen.gcurrent_class).cl_module path tfunc.tf_expr.epos in
if in_unsafe then cls.cl_meta <- (Meta.Unsafe,[],Ast.null_pos) :: cls.cl_meta;
if Common.defined gen.gcon Define.EraseGenerics then begin
cls.cl_meta <- (Meta.HaxeGeneric,[],Ast.null_pos) :: cls.cl_meta
end;
cls.cl_module <- (get ft.fgen.gcurrent_class).cl_module;
cls.cl_params <- cltypes;
let mk_this v pos =
{
(mk_field_access gen { eexpr = TConst TThis; etype = TInst(cls, List.map snd cls.cl_params); epos = pos } v.v_name pos)
with etype = v.v_type
}
in
let mk_this_assign v pos =
{
eexpr = TBinop(OpAssign, mk_this v pos, { eexpr = TLocal(v); etype = v.v_type; epos = pos });
etype = v.v_type;
epos = pos
} in
(* mk_class_field name t public pos kind params *)
let ctor_args, ctor_sig, ctor_exprs = List.fold_left (fun (ctor_args, ctor_sig, ctor_exprs) lexpr ->
match lexpr.eexpr with
| TLocal(v) ->
let cf = mk_class_field v.v_name v.v_type false lexpr.epos (Var({ v_read = AccNormal; v_write = AccNormal; })) [] in
cls.cl_fields <- PMap.add v.v_name cf cls.cl_fields;
cls.cl_ordered_fields <- cf :: cls.cl_ordered_fields;
let ctor_v = alloc_var v.v_name v.v_type in
((ctor_v, None) :: ctor_args, (v.v_name, false, v.v_type) :: ctor_sig, (mk_this_assign v cls.cl_pos) :: ctor_exprs)
| _ -> assert false
) ([],[],[]) captured in
(* change all captured variables to this.capturedVariable *)
let rec change_captured e =
match e.eexpr with
| TLocal( ({ v_capture = true }) as v ) when Hashtbl.mem captured_ht v.v_id ->
mk_this v e.epos
| _ -> Type.map_expr change_captured e
in
let func_expr = change_captured tfunc.tf_expr in
let invokecf, invoke_field, super_args = match delegate_type with
| None -> (* no delegate *)
let ifield, sa = ft.closure_to_classfield { tfunc with tf_expr = func_expr } fexpr.etype fexpr.epos in
ifield,ifield,sa
| Some _ ->
let pos = cls.cl_pos in
let cf = mk_class_field "Delegate" (TFun(fun_args tfunc.tf_args, tfunc.tf_type)) true pos (Method MethNormal) [] in
cf.cf_expr <- Some { fexpr with eexpr = TFunction { tfunc with tf_expr = func_expr }; };
cf.cf_meta <- (Meta.Final,[],pos) :: cf.cf_meta;
cls.cl_ordered_fields <- cf :: cls.cl_ordered_fields;
cls.cl_fields <- PMap.add cf.cf_name cf cls.cl_fields;
(* invoke function body: call Delegate function *)
let ibody = {
eexpr = TCall({
eexpr = TField({
eexpr = TConst TThis;
etype = TInst(cls, List.map snd cls.cl_params);
epos = pos;
}, FInstance(cls, List.map snd cls.cl_params, cf));
etype = cf.cf_type;
epos = pos;
}, List.map (fun (v,_) -> mk_local v pos) tfunc.tf_args);
etype = tfunc.tf_type;
epos = pos
} in
let ibody = if not (is_void tfunc.tf_type) then
{ ibody with eexpr = TReturn( Some ibody ) }
else
ibody
in
let ifield, sa = ft.closure_to_classfield { tfunc with tf_expr = ibody } fexpr.etype fexpr.epos in
cf,ifield,sa
in
(* create the constructor *)
(* todo properly abstract how type var is set *)
cls.cl_super <- Some(parent_func_class, []);
let pos = cls.cl_pos in
let super_call =
{
eexpr = TCall({ eexpr = TConst(TSuper); etype = TInst(parent_func_class,[]); epos = pos }, super_args);
etype = ft.fgen.gcon.basic.tvoid;
epos = pos;
} in
let ctor_type = (TFun(ctor_sig, ft.fgen.gcon.basic.tvoid)) in
let ctor = mk_class_field "new" ctor_type true cls.cl_pos (Method(MethNormal)) [] in
ctor.cf_expr <- Some(
{
eexpr = TFunction(
{
tf_args = ctor_args;
tf_type = ft.fgen.gcon.basic.tvoid;
tf_expr = { eexpr = TBlock(super_call :: ctor_exprs); etype = ft.fgen.gcon.basic.tvoid; epos = cls.cl_pos }
});
etype = ctor_type;
epos = cls.cl_pos;
});
cls.cl_constructor <- Some(ctor);
(* add invoke function to the class *)
cls.cl_ordered_fields <- invoke_field :: cls.cl_ordered_fields;
cls.cl_fields <- PMap.add invoke_field.cf_name invoke_field cls.cl_fields;
cls.cl_overrides <- invoke_field :: cls.cl_overrides;
(* add this class to the module with gadd_to_module *)
ft.fgen.gadd_to_module (TClassDecl(cls)) priority;
(* if there are no captured variables, we can create a cache so subsequent calls don't need to create a new function *)
let expr, clscapt =
match captured, tparams with
| [], [] ->
let cache_var = ft.fgen.gmk_internal_name "hx" "current" in
let cache_cf = mk_class_field cache_var (TInst(cls,[])) false func_expr.epos (Var({ v_read = AccNormal; v_write = AccNormal })) [] in
cls.cl_ordered_statics <- cache_cf :: cls.cl_ordered_statics;
cls.cl_statics <- PMap.add cache_var cache_cf cls.cl_statics;
(* if (FuncClass.hx_current != null) FuncClass.hx_current; else (FuncClass.hx_current = new FuncClass()); *)
(* let mk_static_field_access cl field fieldt pos = *)
let hx_current = mk_static_field_access cls cache_var (TInst(cls,[])) func_expr.epos in
let pos = func_expr.epos in
{ fexpr with
eexpr = TIf(
{
eexpr = TBinop(OpNotEq, hx_current, null (TInst(cls,[])) pos);
etype = ft.fgen.gcon.basic.tbool;
epos = pos;
},
hx_current,
Some(
{
eexpr = TBinop(OpAssign, hx_current, { fexpr with eexpr = TNew(cls, [], captured) });
etype = (TInst(cls,[]));
epos = pos;
}))
}, (cls,captured)
| _ ->
(* change the expression so it will be a new "added class" ( captured variables arguments ) *)
{ fexpr with eexpr = TNew(cls, List.map (fun cl -> TInst(cl,[])) tparams, List.rev captured) }, (cls,captured)
in
match delegate_type with
| None ->
expr,clscapt
| Some _ ->
{
eexpr = TField(expr, FClosure(Some (cls,[]),invokecf)); (* TODO: FClosure change *)
etype = invokecf.cf_type;
epos = cls.cl_pos
}, clscapt
in
let tvar_to_cdecl = Hashtbl.create 0 in
traverse
ft.fgen
~tparam_anon_decl:(fun v e fn ->
let _, info = handle_anon_func e fn null_map_info None in
Hashtbl.add tvar_to_cdecl v.v_id info
)
~tparam_anon_acc:(fun v e -> try
let cls, captured = Hashtbl.find tvar_to_cdecl v.v_id in
let types = match v.v_extra with
| Some(t,_) -> t
| _ -> assert false
in
let monos = List.map (fun _ -> mk_mono()) types in
let vt = match follow v.v_type with
| TInst(_, [v]) -> v
| v -> v
in
let et = match follow e.etype with
| TInst(_, [v]) -> v
| v -> v
in
let original = apply_params types monos vt in
unify et original;
let monos = List.map (fun t -> apply_params types (List.map (fun _ -> t_dynamic) types) t) monos in
let same_cl t1 t2 = match follow t1, follow t2 with
| TInst(c,_), TInst(c2,_) -> c == c2
| _ -> false
in
let passoc = List.map2 (fun (_,t) m -> t,m) types monos in
let cltparams = List.map (fun (_,t) ->
try
snd (List.find (fun (t2,_) -> same_cl t t2) passoc)
with | Not_found -> t) cls.cl_params
in
{ e with eexpr = TNew(cls, cltparams, captured) }
with
| Not_found ->
gen.gcon.warning "This expression may be invalid" e.epos;
e
| Unify_error el ->
List.iter (fun el -> gen.gcon.warning (Typecore.unify_error_msg (print_context()) el) e.epos) el;
gen.gcon.warning "This expression may be invalid" e.epos;
e
)
(* (transform_closure:texpr->texpr->string->texpr) (handle_anon_func:texpr->tfunc->texpr) (dynamic_func_call:texpr->texpr->texpr list->texpr) *)
ft.transform_closure
(fun e f info delegate_type -> fst (handle_anon_func e f info delegate_type))
ft.dynamic_fun_call
(* (dynamic_func_call:texpr->texpr->texpr list->texpr) *)
let configure gen (mapping_func:texpr->texpr) =
let map e = Some(mapping_func e) in
gen.gexpr_filters#add ~name:name ~priority:(PCustom priority) map
let configure_as_synf gen (mapping_func:texpr->texpr) =
let map e = Some(mapping_func e) in
gen.gsyntax_filters#add ~name:name ~priority:(PCustom priority_as_synf) map
(*
this submodule will provide the default implementation for the C# and Java targets.
it will have two return types: double and dynamic, and
*)
module DoubleAndDynamicClosureImpl =
struct
let get_ctx gen max_arity =
let basic = gen.gcon.basic in
let func_args_i i =
let rec loop i (acc) =
if i = 0 then (acc) else begin
let vfloat = alloc_var (gen.gmk_internal_name "fn" ("float" ^ string_of_int i)) basic.tfloat in
let vdyn = alloc_var (gen.gmk_internal_name "fn" ("dyn" ^ string_of_int i)) t_dynamic in
loop (i - 1) ((vfloat, None) :: (vdyn, None) :: acc)
end
in
loop i []
in
let args_real_to_func args =
let arity = List.length args in
if arity >= max_arity then
[ alloc_var (gen.gmk_internal_name "fn" "dynargs") (basic.tarray t_dynamic), None ]
else func_args_i arity
in
let func_sig_i i =
let rec loop i acc =
if i = 0 then acc else begin
let vfloat = gen.gmk_internal_name "fn" ("float" ^ string_of_int i) in
let vdyn = gen.gmk_internal_name "fn" ("dyn" ^ string_of_int i) in
loop (i - 1) ( (vfloat,false,basic.tfloat) :: (vdyn,false,t_dynamic) :: acc )
end
in
loop i []
in
let args_real_to_func_sig args =
let arity = List.length args in
if arity >= max_arity then
[gen.gmk_internal_name "fn" "dynargs", false, basic.tarray t_dynamic]
else begin
func_sig_i arity
end
in
let rettype_real_to_func t = match run_follow gen t with
| TType({ t_path = [],"Null" }, _) ->
0,t_dynamic
| _ when like_float t && not (like_i64 t) ->
(1, basic.tfloat)
| _ ->
(0, t_dynamic)
in
let args_real_to_func_call el (pos:Ast.pos) =
if List.length el >= max_arity then
[{ eexpr = TArrayDecl el; etype = basic.tarray t_dynamic; epos = pos }]
else begin
List.fold_left (fun acc e ->
if like_float (gen.greal_type e.etype) && not (like_i64 (gen.greal_type e.etype)) then
( e :: undefined e.epos :: acc )
else
( null basic.tfloat e.epos :: e :: acc )
) ([]) (List.rev el)
end
in
let const_type c def =
match c with
| TString _ -> basic.tstring | TInt _ -> basic.tint
| TFloat _ -> basic.tfloat | TBool _ -> basic.tbool
| _ -> def
in
let get_args_func args changed_args pos =
let arity = List.length args in
let mk_const const elocal t =
match const with
| None -> mk_cast t elocal
| Some const ->
{ eexpr = TIf(
{ elocal with eexpr = TBinop(Ast.OpEq, elocal, null elocal.etype elocal.epos); etype = basic.tbool },
{ elocal with eexpr = TConst(const); etype = const_type const t },
Some ( mk_cast t elocal )
); etype = t; epos = elocal.epos }
in
if arity >= max_arity then begin
let varray = match changed_args with | [v,_] -> v | _ -> assert false in
let varray_local = mk_local varray pos in
let mk_varray i = { eexpr = TArray(varray_local, { eexpr = TConst(TInt(Int32.of_int i)); etype = basic.tint; epos = pos }); etype = t_dynamic; epos = pos } in
snd (List.fold_left (fun (count,acc) (v,const) ->
(count + 1,
{
eexpr = TVar(v, Some(mk_const const ( mk_varray count ) v.v_type));
etype = basic.tvoid;
epos = pos;
} :: acc)
) (0,[]) args)
end else begin
let _, dyn_args, float_args = List.fold_left (fun (count,fargs, dargs) arg ->
if count land 1 = 0 then
(count + 1, fargs, arg :: dargs)
else
(count + 1, arg :: fargs, dargs)
) (1,[],[]) (List.rev changed_args) in
let rec loop acc args fargs dargs =
match args, fargs, dargs with
| [], [], [] -> acc
| (v,const) :: args, (vf,_) :: fargs, (vd,_) :: dargs ->
let acc = { eexpr = TVar(v, Some(
{
eexpr = TIf(
{ eexpr = TBinop(Ast.OpEq, mk_local vd pos, undefined pos); etype = basic.tbool; epos = pos },
mk_cast v.v_type (mk_local vf pos),
Some ( mk_const const (mk_local vd pos) v.v_type )
);
etype = v.v_type;
epos = pos
} )); etype = basic.tvoid; epos = pos } :: acc in
loop acc args fargs dargs
| _ -> assert false
in
loop [] args float_args dyn_args
end
in
let closure_to_classfield tfunc old_sig pos =
(* change function signature *)
let old_args = tfunc.tf_args in
let changed_args = args_real_to_func old_args in
(*
FIXME properly handle int64 cases, which will break here (because of inference to int)
UPDATE: the fix will be that Int64 won't be a typedef to Float/Int
*)
let changed_sig, arity, type_number, changed_sig_ret, is_void, is_dynamic_func = match follow old_sig with
| TFun(_sig, ret) ->
let type_n, ret_t = rettype_real_to_func ret in
let arity = List.length _sig in
let is_dynamic_func = arity >= max_arity in
let ret_t = if is_dynamic_func then t_dynamic else ret_t in
(TFun(args_real_to_func_sig _sig, ret_t), arity, type_n, ret_t, is_void ret, is_dynamic_func)
| _ -> (print_endline (s_type (print_context()) (follow old_sig) )); assert false
in
let tf_expr = if is_void then begin
let rec map e =
match e.eexpr with
| TReturn None -> { e with eexpr = TReturn (Some (null t_dynamic e.epos)) }
| _ -> Type.map_expr map e
in
let e = mk_block (map tfunc.tf_expr) in
match e.eexpr with
| TBlock(bl) ->
{ e with eexpr = TBlock(bl @ [{ eexpr = TReturn (Some (null t_dynamic e.epos)); etype = t_dynamic; epos = e.epos }]) }
| _ -> assert false
end else tfunc.tf_expr in
let changed_sig_ret = if is_dynamic_func then t_dynamic else changed_sig_ret in
(* get real arguments on top of function body *)
let get_args = get_args_func tfunc.tf_args changed_args pos in
(*
FIXME HACK: in order to be able to run the filters that have already ran for this piece of code,
we will cheat and run it as if it was the whole code
We could just make ClosuresToClass run before TArrayTransform, but we cannot because of the
dependency between ClosuresToClass (after DynamicFieldAccess, and before TArrayTransform)
maybe a way to solve this would be to add an "until" field to run_from
*)
let real_get_args = gen.gexpr_filters#run_f { eexpr = TBlock(get_args); etype = basic.tvoid; epos = pos } in
let func_expr = Type.concat real_get_args tf_expr in
(* set invoke function *)
(* todo properly abstract how naming for invoke is made *)
let invoke_name = if is_dynamic_func then "invokeDynamic" else ("invoke" ^ (string_of_int arity) ^ (if type_number = 0 then "_o" else "_f")) in
let invoke_name = gen.gmk_internal_name "hx" invoke_name in
let invoke_field = mk_class_field invoke_name changed_sig false func_expr.epos (Method(MethNormal)) [] in
let invoke_fun =
{
eexpr = TFunction(
{
tf_args = changed_args;
tf_type = changed_sig_ret;
tf_expr = func_expr;
});
etype = changed_sig;
epos = func_expr.epos;
} in
invoke_field.cf_expr <- Some(invoke_fun);
(invoke_field, [
{ eexpr = TConst(TInt( Int32.of_int arity )); etype = gen.gcon.basic.tint; epos = pos };
{ eexpr = TConst(TInt( Int32.of_int type_number )); etype = gen.gcon.basic.tint; epos = pos };
])
in
let dynamic_fun_call call_expr =
let tc, params = match call_expr.eexpr with
| TCall(tc, params) -> (tc, params)
| _ -> assert false
in
let ct = gen.greal_type call_expr.etype in
let postfix, ret_t =
if like_float ct && not (like_i64 ct) then
"_f", gen.gcon.basic.tfloat
else
"_o", t_dynamic
in
let params_len = List.length params in
let ret_t = if params_len >= max_arity then t_dynamic else ret_t in
let invoke_fun = if params_len >= max_arity then "invokeDynamic" else "invoke" ^ (string_of_int params_len) ^ postfix in
let invoke_fun = gen.gmk_internal_name "hx" invoke_fun in
let fun_t = match follow tc.etype with
| TFun(_sig, _) ->
TFun(args_real_to_func_sig _sig, ret_t)
| _ ->
let i = ref 0 in
let _sig = List.map (fun p -> let name = "arg" ^ (string_of_int !i) in incr i; (name,false,p.etype) ) params in
TFun(args_real_to_func_sig _sig, ret_t)
in
let may_cast = match follow call_expr.etype with
| TAbstract ({ a_path = ([], "Void") },[]) -> (fun e -> e)
| _ -> mk_cast call_expr.etype
in
may_cast
{
eexpr = TCall(
{ (mk_field_access gen { tc with etype = gen.greal_type tc.etype } invoke_fun tc.epos) with etype = fun_t },
args_real_to_func_call params call_expr.epos
);
etype = ret_t;
epos = call_expr.epos
}
in
let iname is_function i is_float =
let postfix = if is_float then "_f" else "_o" in
gen.gmk_internal_name "hx" ("invoke" ^ (if not is_function then "Field" else "") ^ string_of_int i) ^ postfix
in
let map_base_classfields cl is_function map_fn =
let pos = cl.cl_pos in
let this_t = TInst(cl,List.map snd cl.cl_params) in
let this = { eexpr = TConst(TThis); etype = this_t; epos = pos } in
let mk_this field t = { (mk_field_access gen this field pos) with etype = t } in
let mk_invoke_i i is_float =
let cf = mk_class_field (iname is_function i is_float) (TFun(func_sig_i i, if is_float then basic.tfloat else t_dynamic)) false pos (Method MethNormal) [] in
cf
in
let type_name = gen.gmk_internal_name "fn" "type" in
let dynamic_arg = alloc_var (gen.gmk_internal_name "fn" "dynargs") (basic.tarray t_dynamic) in
let mk_invoke_complete_i i is_float =
(* let arity = i in *)
let args = func_args_i i in
(* api fn *)
(* only cast if needed *)
let mk_cast tto efrom = gen.ghandle_cast (gen.greal_type tto) (gen.greal_type efrom.etype) efrom in
let api i t const =
let vf, _ = List.nth args (i * 2) in
let vo, _ = List.nth args (i * 2 + 1) in
let needs_cast, is_float = match t, like_float t && not (like_i64 t) with
| TAbstract({ a_path = ([], "Float") },[]), _ -> false, true
| _, true -> true, true
| _ -> false,false
in
let olocal = mk_local vo pos in
let flocal = mk_local vf pos in
let get_from_obj e = match const with
| None -> mk_cast t e
| Some tc ->
{
eexpr = TIf(
{ eexpr = TBinop(Ast.OpEq, olocal, null t_dynamic pos); etype = basic.tbool; epos = pos } ,
{ eexpr = TConst(tc); etype = t; epos = pos },
Some (mk_cast t e)
);
etype = t;
epos = pos;
}
in
{
eexpr = TIf(
{ eexpr = TBinop(Ast.OpEq, olocal, undefined pos); etype = basic.tbool; epos = pos },
(if needs_cast then mk_cast t flocal else flocal),
Some ( get_from_obj olocal )
);
etype = t;
epos = pos
}
in
(* end of api fn *)
let ret = if is_float then basic.tfloat else t_dynamic in
let added_args, fn_expr = map_fn i ret (List.map fst args) api in
let args = added_args @ args in
let t = TFun(fun_args args, ret) in
let tfunction =
{
eexpr = TFunction({
tf_args = args;
tf_type = ret;
tf_expr =
mk_block fn_expr
});
etype = t;
epos = pos;
}
in
let cf = mk_invoke_i i is_float in
cf.cf_expr <- Some tfunction;
cf
in
let rec loop i cfs =
if i < 0 then cfs else begin
(*let mk_invoke_complete_i i is_float =*)
(mk_invoke_complete_i i false) :: (mk_invoke_complete_i i true) :: (loop (i-1) cfs)
end
in
let cfs = loop max_arity [] in
let added_s_args, switch =
let api i t const =
match i with
| -1 ->
mk_local dynamic_arg pos
| _ ->
mk_cast t {
eexpr = TArray(
mk_local dynamic_arg pos,
{ eexpr = TConst(TInt(Int32.of_int i)); etype = basic.tint; epos = pos });
etype = t;
epos = pos;
}
in
map_fn (-1) t_dynamic [dynamic_arg] api
in
let args = added_s_args @ [dynamic_arg, None] in
let dyn_t = TFun(fun_args args, t_dynamic) in
let dyn_cf = mk_class_field (gen.gmk_internal_name "hx" "invokeDynamic") dyn_t false pos (Method MethNormal) [] in
dyn_cf.cf_expr <-
Some {
eexpr = TFunction({
tf_args = args;
tf_type = t_dynamic;
tf_expr = mk_block switch
});
etype = dyn_t;
epos = pos;
};
let additional_cfs = if is_function then begin
let new_t = TFun(["arity", false, basic.tint; "type", false, basic.tint],basic.tvoid) in
let new_cf = mk_class_field "new" (new_t) true pos (Method MethNormal) [] in
let v_arity, v_type = alloc_var "arity" basic.tint, alloc_var "type" basic.tint in
let mk_assign v field = { eexpr = TBinop(Ast.OpAssign, mk_this field v.v_type, mk_local v pos); etype = v.v_type; epos = pos } in
let arity_name = gen.gmk_internal_name "hx" "arity" in
new_cf.cf_expr <-
Some {
eexpr = TFunction({
tf_args = [v_arity, None; v_type, None];
tf_type = basic.tvoid;
tf_expr =
{
eexpr = TBlock([
mk_assign v_type type_name;
mk_assign v_arity arity_name
]);
etype = basic.tvoid;
epos = pos;
}
});
etype = new_t;
epos = pos;
}
;
[
new_cf;
mk_class_field type_name basic.tint true pos (Var { v_read = AccNormal; v_write = AccNormal }) [];
mk_class_field arity_name basic.tint true pos (Var { v_read = AccNormal; v_write = AccNormal }) [];
]
end else [] in
dyn_cf :: (additional_cfs @ cfs)
in
(* maybe another param for prefix *)
let get_base_classfields_for cl is_function mk_additional_args =
let pos = cl.cl_pos in
let this_t = TInst(cl,List.map snd cl.cl_params) in
let this = { eexpr = TConst(TThis); etype = this_t; epos = pos } in
let mk_this field t = { (mk_field_access gen this field pos) with etype = t } in
let rec mk_dyn_call arity api =
let zero = { eexpr = TConst(TFloat("0.0")); etype = basic.tfloat; epos = pos } in
let rec loop i acc =
if i = 0 then acc else begin
let arr = api (i-1) t_dynamic None in
loop (i - 1) (zero :: arr :: acc)
end
in
loop arity ([])
in
let mk_invoke_switch i (api:(int->t->tconstant option->texpr)) =
let t = TFun(func_sig_i i,t_dynamic) in
(* case i: return this.invokeX_o(0, 0, 0, 0, 0, ... arg[0], args[1]....); *)
( [{ eexpr = TConst(TInt(Int32.of_int i)); etype = basic.tint; epos = pos }],
{
eexpr = TReturn(Some( {
eexpr = TCall(mk_this (iname is_function i false) t, mk_dyn_call i api);
etype = t_dynamic;
epos = pos;
} ));
etype = t_dynamic;
epos = pos;
} )
in
let cl_t = TInst(cl,List.map snd cl.cl_params) in
let this = { eexpr = TConst(TThis); etype = cl_t; epos = pos } in
let mk_this field t = { (mk_field_access gen this field pos) with etype = t } in
let mk_int i = { eexpr = TConst(TInt ( Int32.of_int i)); etype = basic.tint; epos = pos } in
let mk_string s = { eexpr = TConst(TString s); etype = basic.tstring; epos = pos } in
(*
if it is the Function class, the base class fields will be
* hx::invokeX_d|o (where X is from 0 to max_arity) (args)
{
if (this.type == 0|1) return invokeX_o|d(args); else throw "Invalid number of arguments."
}
hx::invokeDynamic, which will work in the same way
new(arity, type)
{
if (type != 0 && type != 1) throw "Invalid type";
this.arity = arity;
this.type = type;
}
*)
let type_name = gen.gmk_internal_name "fn" "type" in
let mk_expr i is_float vars =
let name = if is_function then "invoke" else "invokeField" in
let look_ahead = alloc_var "lookAhead" basic.tbool in
let add_args = if not is_function then mk_additional_args() else [] in
let vars = if not is_function then (List.map fst add_args) @ (look_ahead :: vars) else vars in
let call_expr =
let call_t = TFun(List.map (fun v -> (v.v_name, false, v.v_type)) vars, if is_float then t_dynamic else basic.tfloat) in
{
eexpr = TCall(mk_this (gen.gmk_internal_name "hx" (name ^ (string_of_int i) ^ (if is_float then "_o" else "_f"))) call_t, List.map (fun v -> if v.v_id = look_ahead.v_id then ( { eexpr = TConst(TBool false); etype = basic.tbool; epos = pos } ) else mk_local v pos) vars );
etype = if is_float then t_dynamic else basic.tfloat;
epos = pos
}
in
(*let call_expr = if is_float then mk_cast basic.tfloat call_expr else call_expr in*)
let if_cond = if is_function then
{ eexpr=TBinop(Ast.OpNotEq, mk_this type_name basic.tint, mk_int (if is_float then 0 else 1) ); etype = basic.tbool; epos = pos }
else
mk_local look_ahead pos
in
let if_expr = if is_function then
{
eexpr = TIf(if_cond,
{ eexpr = TThrow(mk_string "Wrong number of arguments"); etype = basic.tstring; epos = pos },
Some( { eexpr = TReturn( Some( call_expr ) ); etype = call_expr.etype; epos = pos } )
);
etype = t_dynamic;
epos = pos;
}
else
{
eexpr = TIf(if_cond,
{ eexpr = TReturn( Some( call_expr ) ); etype = call_expr.etype; epos = pos },
Some( { eexpr = TThrow(mk_string "Field not found or wrong number of arguments"); etype = basic.tstring; epos = pos } )
);
etype = t_dynamic;
epos = pos;
}
in
let args = if not is_function then (mk_additional_args()) @ [look_ahead, None] else [] in
(args, if_expr)
in
let arities_processed = Hashtbl.create 10 in
let max_arity = ref 0 in
let rec loop_cases api arity acc =
if arity < 0 then acc else
loop_cases api (arity - 1) (mk_invoke_switch arity api :: acc)
in
(* let rec loop goes here *)
let map_fn cur_arity fun_ret_type vars (api:(int->t->tconstant option->texpr)) =
let is_float = like_float fun_ret_type && not (like_i64 fun_ret_type) in
match cur_arity with
| -1 ->
let dynargs = api (-1) (t_dynamic) None in
let switch_cond = mk_field_access gen dynargs "length" pos in
let switch_cond = {
eexpr = TIf(
{ eexpr = TBinop(Ast.OpEq, dynargs, null dynargs.etype pos); etype = basic.tbool; epos = pos; },
{ eexpr = TConst(TInt(Int32.zero)); etype = basic.tint; epos = pos },
Some switch_cond);
etype = basic.tint;
epos = pos;
} in
let switch =
{
eexpr = TSwitch( switch_cond,
loop_cases api !max_arity [],
Some({ eexpr = TThrow(mk_string "Too many arguments"); etype = basic.tvoid; epos = pos; }) );
etype = basic.tvoid;
epos = pos;
} in
( (if not is_function then mk_additional_args () else []), switch )
| _ ->
if not (Hashtbl.mem arities_processed cur_arity) then begin
Hashtbl.add arities_processed cur_arity true;
if cur_arity > !max_arity then max_arity := cur_arity
end;
mk_expr cur_arity is_float vars
in
map_base_classfields cl is_function map_fn
in
let initialize_base_class cl =
()
in
{
fgen = gen;
func_class = null_class;
closure_to_classfield = closure_to_classfield;
dynamic_fun_call = dynamic_fun_call;
(*
called once so the implementation can make one of a time initializations in the base class
for all functions
*)
initialize_base_class = initialize_base_class;
(*
Base classfields are the class fields for the abstract implementation of either the Function implementation,
or the invokeField implementation for the classes
They will either try to call the right function or will fail with
(tclass - subject (so we know the type of this)) -> is_function_base -> list of the abstract implementation class fields
*)
get_base_classfields_for = get_base_classfields_for;
map_base_classfields = map_base_classfields;
(*
for now we won't deal with the closures.
They can be dealt with the module ReflectionCFs,
or a custom implementation
*)
transform_closure = (fun tclosure texpr str -> tclosure);
}
end;;
end;;
(* ******************************************* *)
(* Type Parameters *)
(* ******************************************* *)
(*
This module will handle type parameters. There are lots of changes we need to do to correctly support type parameters:
traverse will:
V Detect when parameterized function calls are made
* Detect when a parameterized class instance is being cast to another parameter
* Change new<> parameterized function calls
*
extras:
* On languages that support "real" type parameters, a Cast function is provided that will convert from a to the requested type.
This cast will call createEmpty with the correct type, and then set each variable to the new form. Some types will be handled specially, namely the Native Array.
Other implementations may be delegated to the runtime.
* parameterized classes will implement a new interface (with only a Cast<> function added to it), so we can access the type parameter for them. Also any reference to will be replaced by a reference to this interface. (also on TTypeExpr - Std.is())
* Type parameter renaming to avoid name clash
* Detect type parameter casting and call Cast<> instead
for java:
* for specially assigned classes, parameters will be replaced by _d and _i versions of parameterized functions. This will only work for parameterized classes, not functions.
dependencies:
must run after casts are detected. This will be ensured at CastDetect module.
*)
module TypeParams =
struct
let name = "type_params"
let priority = max_dep -. 20.
let rec deep_follow gen t = match run_follow gen t with
| TInst(c,tl) ->
TInst(c,List.map (deep_follow gen) tl)
| TEnum(e,tl) ->
TEnum(e,List.map (deep_follow gen) tl)
| TAbstract(a,tl) ->
TAbstract(a,List.map (deep_follow gen) tl)
| TType(t,tl) ->
TType(t,List.map (deep_follow gen) tl)
| TFun(args,ret) ->
TFun(List.map (fun (n,o,t) -> n,o,deep_follow gen t) args, deep_follow gen ret)
| t -> t
(* this function will receive the original function argument, the applied function argument and the original function parameters. *)
(* from this info, it will infer the applied tparams for the function *)
(* this function is used by CastDetection module *)
let infer_params gen pos (original_args:((string * bool * t) list * t)) (applied_args:((string * bool * t) list * t)) (params:(string * t) list) calls_parameters_explicitly : tparams =
match params with
| [] -> []
| _ ->
let args_list args = (if not calls_parameters_explicitly then t_dynamic else snd args) :: (List.map (fun (n,o,t) -> t) (fst args)) in
let monos = List.map (fun _ -> mk_mono()) params in
let original = args_list (get_fun (apply_params params monos (TFun(fst original_args,snd original_args)))) in
let applied = args_list applied_args in
(try
List.iter2 (fun a o ->
let o = deep_follow gen o in
let a = deep_follow gen a in
unify a o
(* type_eq EqStrict a o *)
) applied original
(* unify applied original *)
with | Unify_error el ->
(* List.iter (fun el -> gen.gcon.warning (Typecore.unify_error_msg (print_context()) el) pos) el; *)
gen.gcon.warning ("This expression may be invalid") pos
| Invalid_argument("List.map2") ->
gen.gcon.warning ("This expression may be invalid") pos
);
List.map (fun t ->
match follow t with
| TMono _ -> t_empty
| t -> t
) monos
(* ******************************************* *)
(* Real Type Parameters Module *)
(* ******************************************* *)
(*
This submodule is by now specially made for the .NET platform. There might be other targets that will
make use of this, but it IS very specific.
On the .NET platform, generics are real specialized classes that are JIT compiled. For this reason, we cannot
cast from one type parameter to another. Also there is no common type for the type parameters, so for example
an instance of type Array will return false for instance is Array